import { theme } from "../../terminal/theme.js";

import {

filterContainerGenericHints,

parsePortFromArgs,

renderGatewayServiceStartHints,

resolveDaemonContainerContext,

resolveRuntimeStatusColor,

});

});

describe("parsePortFromArgs", () => {

it("rejects inline port values with trailing equals-separated text", () => {

expect(parsePortFromArgs(["--port=123=bad"])).toBeNull();

});

it("accepts valid inline and space-separated port values", () => {

expect(parsePortFromArgs(["--port=14720"])).toBe(14_720);

expect(parsePortFromArgs(["--port", "14721"])).toBe(14_721);

});

});

describe("renderGatewayServiceStartHints", () => {

it("resolves daemon container context from either env key", () => {

expect(

buildPlatformRuntimeLogHints,

buildPlatformServiceStartHints,

} from "../../daemon/runtime-hints.js";

import { parseInlineOptionToken } from "../../infra/inline-option-token.js";

import { colorize, isRich, theme } from "../../terminal/theme.js";

import { formatCliCommand } from "../command-format.js";

import { parsePort } from "../shared/parse-port.js";

}

}

if (arg?.startsWith("--port=")) {

const parsed = parsePort(arg.split("=", 2)[1]);

const option = parseInlineOptionToken(arg);

const parsed = parsePort(option.hasInlineValue ? option.inlineValue : undefined);

if (parsed) {

return parsed;

}

import { isValueToken } from "../infra/cli-root-options.js";

import { parseInlineOptionToken } from "../infra/inline-option-token.js";

export function takeCliRootOptionValue(

raw: string,

value: string | null;

consumedNext: boolean;

} {

if (raw.includes("=")) {

const value = raw.slice(raw.indexOf("=") + 1);

const trimmed = (value ?? "").trim();

const parsed = parseInlineOptionToken(raw);

if (parsed.hasInlineValue) {

const trimmed = (parsed.inlineValue ?? "").trim();

return { value: trimmed || null, consumedNext: false };

}

const consumedNext = isValueToken(next);

import { splitShellArgs } from "../utils/shell-argv.js";

import { normalizeExecutableToken } from "./exec-wrapper-tokens.js";

import { parseInlineOptionToken } from "./inline-option-token.js";

export const COMMAND_CARRIER_EXECUTABLES = new Set(["sudo", "doas", "env", "command", "builtin"]);

}

function optionName(token: string): string {

return token.split("=", 1)[0] ?? token;

return parseInlineOptionToken(token).name;

}

type ParsedCarrierOption = {

nonExecutingOptions: ReadonlySet<string> = new Set(),

): ParsedCarrierOption[] | null {

if (token.startsWith("--")) {

const name = optionName(token);

const option = parseInlineOptionToken(token);

const name = option.name;

if (

standaloneOptions.has(name) ||

optionsWithValue.has(name) ||

nonExecutingOptions.has(name)

) {

const valueDelimiter = token.indexOf("=");

return [

{

name,

hasInlineValue: valueDelimiter >= 0,

inlineValue: valueDelimiter >= 0 ? token.slice(valueDelimiter + 1) : undefined,

},

];

const parsedOption: ParsedCarrierOption = {

name,

hasInlineValue: option.hasInlineValue,

};

if (option.hasInlineValue) {

parsedOption.inlineValue = option.inlineValue;

}

return [parsedOption];

}

return null;

}

unwrapEnvInvocation,

} from "./command-carriers.js";

import { normalizeExecutableToken } from "./exec-wrapper-tokens.js";

import { parseInlineOptionToken } from "./inline-option-token.js";

export { unwrapEnvInvocation } from "./command-carriers.js";

if (!token.startsWith("-") || token === "-") {

return "stop";

}

const [flag] = lower.split("=", 2);

const { name: flag } = parseInlineOptionToken(lower);

return params.onFlag(flag, lower);

},

adjustCommandIndex: params.adjustCommandIndex,

return false;

}

const lower = normalizeLowercaseStringOrEmpty(token);

const [flag] = lower.split("=", 2);

const { name: flag } = parseInlineOptionToken(lower);

if (flag === "-o" || flag === "--output") {

return true;

}

if (!lower.startsWith("-") || lower === "-") {

return "stop";

}

const [flag] = token.split("=", 2);

const { name: flag } = parseInlineOptionToken(token);

if (BSD_SCRIPT_OPTIONS_WITH_VALUE.has(flag)) {

return token.includes("=") ? "continue" : "consume-next";

}

import { describe, expect, it } from "vitest";

import { parseInlineOptionToken } from "./inline-option-token.js";

describe("parseInlineOptionToken", () => {

it("preserves equals signs after the first separator", () => {

expect(parseInlineOptionToken("--config=a=b.json")).toEqual({

name: "--config",

hasInlineValue: true,

inlineValue: "a=b.json",

});

expect(parseInlineOptionToken("--token=abc==")).toEqual({

name: "--token",

hasInlineValue: true,

inlineValue: "abc==",

});

});

it("distinguishes empty inline values from missing separators", () => {

expect(parseInlineOptionToken("--token=")).toEqual({

name: "--token",

hasInlineValue: true,

inlineValue: "",

});

expect(parseInlineOptionToken("--token")).toEqual({

name: "--token",

hasInlineValue: false,

});

});

});

export type InlineOptionToken =

| {

name: string;

hasInlineValue: false;

}

| {

name: string;

hasInlineValue: true;

inlineValue: string;

};

export function parseInlineOptionToken(token: string): InlineOptionToken {

const separatorIndex = token.indexOf("=");

if (separatorIndex < 0) {

return { name: token, hasInlineValue: false };

}

return {

name: token.slice(0, separatorIndex),

hasInlineValue: true,

inlineValue: token.slice(separatorIndex + 1),

};

}

fs.writeFileSync(path.join(tmp, "preload.mjs"), 'console.log("SAFE")\n');

},

},

{

name: "rejects node inline import values that contain equals signs",

binName: "node",

tmpPrefix: "openclaw-node-import-inline-equals-",

command: ["node", "--import=./pre=load.mjs", "./main.mjs"],

setup: (tmp) => {

fs.writeFileSync(path.join(tmp, "main.mjs"), 'console.log("SAFE")\n');

fs.writeFileSync(path.join(tmp, "pre=load.mjs"), 'console.log("SAFE")\n');

},

},

{

name: "rejects ruby require preloads that approval cannot bind completely",

binName: "ruby",

unwrapKnownShellMultiplexerInvocation,

} from "../infra/exec-wrapper-resolution.js";

import { sameFileIdentity } from "../infra/fs-safe-advanced.js";

import { parseInlineOptionToken } from "../infra/inline-option-token.js";

import {

advancePosixInlineOptionScan,

POSIX_INLINE_COMMAND_FLAGS,

const PERL_UNSAFE_APPROVAL_FLAGS = new Set(["-I", "-M", "-m"]);

function normalizeOptionFlag(token: string): string {

return normalizeLowercaseStringOrEmpty(token.split("=", 1)[0]);

return normalizeLowercaseStringOrEmpty(parseInlineOptionToken(token).name);

}

function readTrimmedArgToken(argv: readonly string[], index: number): string {

return { hits: [], sawOptionValueFile: false };

}

if (token.startsWith("-")) {

const [flag, inlineValue] = token.split("=", 2);

const option = parseInlineOptionToken(token);

const flag = option.name;

const inlineValue = option.hasInlineValue ? option.inlineValue : undefined;

if (params.optionsWithFileValue?.has(normalizeLowercaseStringOrEmpty(flag))) {

if (inlineValue && resolvesToExistingFileSync(inlineValue, params.cwd)) {

hits.push(i);