newmark-agent 0.3.10 → 0.3.12

package/config.example.json

@@ -11,6 +11,12 @@
       "_type": "choice",
       "_values": ["en", "zh", "auto"],
       "value": "auto"
+    },
+    "close_behavior": {
+      "_description": "Close behavior",
+      "_type": "choice",
+      "_values": ["minimize", "exit"],
+      "value": "exit"
     }
   },
   "ui": {

package/dist/cli-commands.d.ts

@@ -1,4 +1,11 @@
 export declare const CLI_COMMANDS: readonly ["state", "tool", "send", "validate-models", "fuzzy-inject", "skills-market", "memory-lab", "install-update", "compat", "compat-tool"];
+/**
+ * Compatibility discovery reads third-party metadata outside the selected
+ * Newmark root. Those manifests can contain provider options, so structured
+ * compatibility output must not become a credential exfiltration path.
+ */
+export declare function redactCliSecrets<T>(value: T, seen?: WeakSet<object>): T;
 export declare function runCliCommand(root: string, args: string[]): Promise<boolean>;
+export declare function cliCommandHelp(command: string): string;
 export declare function cliCommandUsage(): string;
 //# sourceMappingURL=cli-commands.d.ts.map

package/dist/cli-commands.js

@@ -34,7 +34,9 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CLI_COMMANDS = void 0;
+exports.redactCliSecrets = redactCliSecrets;
 exports.runCliCommand = runCliCommand;
+exports.cliCommandHelp = cliCommandHelp;
 exports.cliCommandUsage = cliCommandUsage;
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
@@ -46,6 +48,97 @@ const compat_1 = require("./core/compat");
 const memoryLab_1 = require("./core/memoryLab");
 const installUpdate_1 = require("./core/installUpdate");
 exports.CLI_COMMANDS = ['state', 'tool', 'send', 'validate-models', 'fuzzy-inject', 'skills-market', 'memory-lab', 'install-update', 'compat', 'compat-tool'];
+const CLI_COMMAND_HELP = {
+    state: [
+        'Usage: Newmark.exe state [--root <dir>]',
+        'Read the current local state as JSON and exit without a model request.',
+    ],
+    tool: [
+        'Usage: Newmark.exe tool <tool-name> [json-args | key=value ... | --args-file path] [--mode build|plan|goal|flow] [--root <dir>]',
+        'Execute one policy-checked tool and return its JSON envelope.',
+    ],
+    send: [
+        'Usage: Newmark.exe send <prompt> [--input-env ENV|--input-file path] [--mode build|plan|goal|flow] [--model <model>] [--language auto|en|zh] [--conversation <id>] [--agent-only] [--root <dir>]',
+        'Send one non-interactive prompt through the selected local model.',
+    ],
+    'validate-models': [
+        'Usage: Newmark.exe validate-models [--selected provider/model,model] [--persist] [--root <dir>]',
+        'Validate configured model deployments without changing config by default; --persist writes validation metadata intentionally.',
+        'An explicit selection with no configured matches prints [] and exits with status 1.',
+    ],
+    'fuzzy-inject': [
+        'Usage: Newmark.exe fuzzy-inject [--name <provider>] [--env-file <file>|--env-file-env <ENV>] [--endpoint-env <ENV>] [--key-env <ENV>] [--protocol openai|anthropic] [--preview-only] [--root <dir>]',
+        'Discover or import a provider; --preview-only keeps the operation local and read-only.',
+    ],
+    'skills-market': [
+        'Usage: Newmark.exe skills-market [--query <text>|--sources|--add-source --name <name> (--url <url>|--path <path>)|--remove-source <id>|--enable-source <id>|--disable-source <id>] [--root <dir>]',
+        'Search or manage local skill-market sources.',
+    ],
+    'memory-lab': [
+        'Usage: Newmark.exe memory-lab [--read|--component <name>|--update ...|--reindex] [--root <dir>]',
+        'Read or update the local Memory Lab index and components.',
+    ],
+    'install-update': [
+        'Usage: Newmark.exe install-update (--source <path>|--check-github|--from-github) [options] [--root <dir>]',
+        'Inspect or apply a local/GitHub update using the selected install target.',
+    ],
+    compat: [
+        'Usage: Newmark.exe compat [--target all|tools|plugins|marketplaces|skills|agents|subagents] [--root <dir>]',
+        'Discover compatible local agent, plugin, marketplace, and skill metadata.',
+    ],
+    'compat-tool': [
+        'Usage: Newmark.exe compat-tool --list | --name <opencode-tool> [json-args | --args-file path] [--root <dir>]',
+        'List or run one compatible OpenCode tool.',
+    ],
+};
+function cliHelpRequested(args) {
+    return args.some(arg => ['--help', '-h'].includes(String(arg).toLowerCase()));
+}
+const CLI_VALUE_FLAGS = new Set([
+    '--root', '--input', '--input-env', '--input-file', '--mode', '--model', '--language', '--conversation',
+    '--args', '--args-file', '--selected', '--models', '--name', '--url', '--key', '--api-key', '--endpoint',
+    '--endpoint-env', '--url-env', '--key-env', '--api-key-env', '--env-file', '--env-file-env',
+    '--claude-env-file', '--claude-env-file-env', '--anthropic-env-file', '--anthropic-env-file-env',
+    '--candidate-models', '--protocol', '--query', '--type', '--path', '--component', '--source-id',
+    '--remove-source', '--enable-source', '--disable-source', '--source', '--target', '--target-file',
+    '--expected-version', '--preserve', '--repo', '--tag', '--asset', '--version', '--content-file',
+    '--content', '--description', '--tags',
+]);
+const CLI_BOOLEAN_FLAGS = new Set([
+    '--persist', '--agent-only', '--list', '--preview-only', '--sources', '--add-source', '--check-github',
+    '--from-github', '--dry-run', '--read', '--index', '--reindex', '--update', '--version', '--folder', '--help', '-h',
+]);
+function invalidCliCommandArgument(args) {
+    let skipNext = false;
+    for (let index = 0; index < args.length; index++) {
+        const arg = String(args[index] || '');
+        if (skipNext) {
+            skipNext = false;
+            continue;
+        }
+        if (!arg || arg === '--' || !arg.startsWith('-'))
+            continue;
+        const name = arg.includes('=') ? arg.slice(0, arg.indexOf('=')) : arg;
+        const hasInlineValue = arg.includes('=');
+        if (CLI_BOOLEAN_FLAGS.has(name))
+            continue;
+        if (CLI_VALUE_FLAGS.has(name)) {
+            if (hasInlineValue) {
+                if (!arg.slice(name.length + 1))
+                    return `${name} requires a value`;
+            }
+            else {
+                const next = args[index + 1];
+                if (!next || String(next).startsWith('-'))
+                    return `${name} requires a value`;
+                skipNext = true;
+            }
+            continue;
+        }
+        return arg;
+    }
+    return undefined;
+}
 function argValue(args, key) {
     const idx = args.indexOf(key);
     return idx >= 0 ? args[idx + 1] : undefined;
@@ -228,6 +321,9 @@ function classifyCliToolOutput(tool, output) {
         const unavailableHostCapability = tool === 'computer_use' || tool.startsWith('browser_');
         return { envelope: { ok: false, tool, error: firstLine, route: 'direct' }, exitCode: unavailableHostCapability ? 3 : 2 };
     }
+    if (/^\[(?:context_compress|context_history_manage)]/i.test(firstLine)) {
+        return { envelope: { ok: false, tool, error: firstLine, route: 'direct' }, exitCode: 4 };
+    }
     if (/^\[(?:tool disabled|permission|Subagent sandbox)]/i.test(firstLine)) {
         return { envelope: { ok: false, tool, error: firstLine, route: 'direct' }, exitCode: 3 };
     }
@@ -382,6 +478,35 @@ function parseFuzzyEnvFile(filePath) {
 function redactUrlSecret(value) {
     return value.replace(/([?&](?:key|token|api_key|auth)=)[^&]+/gi, '$1<redacted>');
 }
+const CLI_SENSITIVE_FIELD = /(?:api.?key|authorization|access.?token|refresh.?token|secret|password|credential|cookie)/i;
+/**
+ * Compatibility discovery reads third-party metadata outside the selected
+ * Newmark root. Those manifests can contain provider options, so structured
+ * compatibility output must not become a credential exfiltration path.
+ */
+function redactCliSecrets(value, seen = new WeakSet()) {
+    const walk = (current) => {
+        if (typeof current === 'string') {
+            return current
+                .replace(/\bsk-[A-Za-z0-9_.-]{8,}\b/gi, 'sk-***REDACTED***')
+                .replace(/\bBearer\s+[A-Za-z0-9_.=:/+_-]{8,}/gi, 'Bearer <redacted>')
+                .replace(/([?&](?:key|token|api_key|auth)=)[^&\s]+/gi, '$1<redacted>');
+        }
+        if (current === null || typeof current !== 'object')
+            return current;
+        if (seen.has(current))
+            return '[CIRCULAR]';
+        seen.add(current);
+        if (Array.isArray(current))
+            return current.map(item => walk(item));
+        const output = {};
+        for (const [key, nested] of Object.entries(current)) {
+            output[key] = CLI_SENSITIVE_FIELD.test(key) ? '[REDACTED]' : walk(nested);
+        }
+        return output;
+    };
+    return walk(value);
+}
 function filterSkillMarket(items, query) {
     const q = (query || '').trim().toLowerCase();
     if (!q)
@@ -539,11 +664,22 @@ async function runCliFuzzyInject(agent, name, url, key, protocol, preferredModel
     };
 }
 async function runCliCommand(root, args) {
-    installCliPipeGuards();
     const command = args.find(a => exports.CLI_COMMANDS.includes(a));
     if (!command)
         return false;
-    const agent = new agent_1.Agent(root, { agentOnly: args.includes('--agent-only') });
+    installCliPipeGuards();
+    const invalidArgument = invalidCliCommandArgument(args);
+    if (invalidArgument) {
+        safeStderr(`Invalid Newmark argument: ${invalidArgument}\n`);
+        process.exitCode = 2;
+        return true;
+    }
+    if (cliHelpRequested(args)) {
+        safeStdout(cliCommandHelp(command));
+        return true;
+    }
+    const readOnlyValidation = command === 'validate-models' && !args.includes('--persist');
+    const agent = new agent_1.Agent(root, { agentOnly: args.includes('--agent-only'), readOnlyConfig: readOnlyValidation });
     agent.tools.setHostProfile({
         kind: 'cli',
         platform: process.platform,
@@ -599,11 +735,19 @@ async function runCliCommand(root, args) {
         const toolArgs = parsedArgs.value;
         const wsDir = agent.workspace.current?.path || root;
         try {
-            const result = await agent.tools.execute(toolName, JSON.stringify(toolArgs), wsDir, {
-                mode: agent.mode,
-                workspacePath: wsDir,
-                invocation: 'cli',
-            });
+            // Context management is an Agent-owned capability. Keep the direct CLI
+            // route on the same handler as model-dispatched calls instead of sending
+            // it through the generic filesystem/native ToolExecutor switch, which
+            // intentionally has no access to conversation history.
+            const result = toolName === 'context_compress'
+                ? (await agent.handleContextCompress(JSON.stringify(toolArgs))).output
+                : toolName === 'context_history_manage'
+                    ? agent.handleContextHistoryManage(JSON.stringify(toolArgs)).output
+                    : await agent.tools.execute(toolName, JSON.stringify(toolArgs), wsDir, {
+                        mode: agent.mode,
+                        workspacePath: wsDir,
+                        invocation: 'cli',
+                    });
             const classified = classifyCliToolOutput(toolName, result);
             emitCliToolEnvelope(classified.envelope, classified.exitCode);
         }
@@ -623,17 +767,50 @@ async function runCliCommand(root, args) {
             return true;
         }
         const model = argValue(args, '--model');
-        if (model)
+        if (model) {
             agent.setModel(model);
-        const tokens = await agent.process(prompt);
-        safeStdout(tokens.map(t => t.text || '').join(''));
-        safeStdout('\n');
+            // Reject a bad explicit selection before Agent.process creates a user
+            // message/work-run or reaches the provider transport. Qualified
+            // provider/model values are normalized by Agent.setModel first.
+            if (model !== 'auto' && !agent.activeModelConfig()) {
+                safeStdout(`[Error] Model '${model}' is unavailable or not configured. Select a configured model or enable a valid provider before sending.`);
+                safeStdout('\n');
+                process.exitCode = 1;
+                return true;
+            }
+        }
+        try {
+            const tokens = await agent.process(prompt);
+            const output = tokens.map(t => t.text || '').join('');
+            safeStdout(output);
+            safeStdout('\n');
+            // Keep the diagnostic in stdout for pipes, but make the non-interactive
+            // command fail when Agent returned a structured error token.
+            if (tokens.some(token => {
+                const text = String(token.text || '');
+                return agent.isLlmErrorText(text) || /^\s*\[(?:Workspace required|Attachment rejected)\]/i.test(text);
+            }))
+                process.exitCode = 1;
+        }
+        catch (error) {
+            // The shared GUI/TUI kernel must throw real terminal failures so it
+            // cannot synthesize a completed WorkRun. Preserve the CLI's stable
+            // stdout diagnostic and non-zero exit contract at this boundary.
+            const message = error instanceof Error ? error.message : String(error);
+            safeStdout(message.startsWith('[') ? message : `[Error] ${message}`);
+            safeStdout('\n');
+            process.exitCode = 1;
+        }
         return true;
     }
     if (command === 'validate-models') {
         const selected = splitList(pathArgValue(args, '--selected') || pathArgValue(args, '--models'));
-        const result = await agent.validateModels(selected.length ? selected : undefined);
+        const result = await agent.validateModels(selected.length ? selected : undefined, { persist: args.includes('--persist') });
         printJson(result);
+        if (selected.length && result.length === 0) {
+            safeStderr(`No configured model deployments matched --selected: ${selected.join(', ')}\n`);
+            process.exitCode = 1;
+        }
         return true;
     }
     if (command === 'fuzzy-inject') {
@@ -846,12 +1023,12 @@ async function runCliCommand(root, args) {
             };
             payload.subagents = agent.subagents.listAll().map(s => agent.subagents.toRecord(s.id));
         }
-        printJson(payload);
+        printJson(redactCliSecrets(payload));
         return true;
     }
     if (command === 'compat-tool') {
         if (args.includes('--list')) {
-            printJson({ ok: true, tools: (0, compat_1.discoverOpenCodeTools)(root) });
+            printJson(redactCliSecrets({ ok: true, tools: (0, compat_1.discoverOpenCodeTools)(root) }));
             return true;
         }
         const positional = positionalAfter(args, 'compat-tool');
@@ -867,11 +1044,25 @@ async function runCliCommand(root, args) {
             process.exitCode = 1;
             return true;
         }
-        printJson(await (0, compat_1.runOpenCodeTool)(root, name, parsedArgs.value));
+        printJson(redactCliSecrets(await (0, compat_1.runOpenCodeTool)(root, name, parsedArgs.value)));
         return true;
     }
     return false;
 }
+function cliCommandHelp(command) {
+    const key = command;
+    const lines = CLI_COMMAND_HELP[key];
+    if (!lines)
+        return `${cliCommandUsage()}\n`;
+    return [
+        `Newmark CLI command: ${command}`,
+        '',
+        ...lines,
+        '',
+        'Flags:',
+        '  --help, -h     Show this command help and exit without network or model work.',
+    ].join('\n') + '\n';
+}
 function cliCommandUsage() {
     return [
         'Newmark CLI non-interactive commands:',

package/dist/cli-discovery.d.ts

@@ -0,0 +1,15 @@
+/** Public version spellings accepted by every Newmark entrypoint. */
+export declare function isVersionArgument(args: string[]): boolean;
+/**
+ * Validate arguments that are interpreted before a command-specific parser is
+ * entered. This keeps malformed launch probes from silently starting a GUI or
+ * falling back to the default user root.
+ */
+export declare function invalidTopLevelArgument(args: string[]): string | undefined;
+/**
+ * Return the first unknown positional top-level token without validating a
+ * command's own arguments. Values belonging to documented flags are skipped,
+ * so a space-containing --root or --input cannot be mistaken for a command.
+ */
+export declare function unknownTopLevelCommand(args: string[]): string | undefined;
+//# sourceMappingURL=cli-discovery.d.ts.map

package/dist/cli-discovery.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isVersionArgument = isVersionArgument;
+exports.invalidTopLevelArgument = invalidTopLevelArgument;
+exports.unknownTopLevelCommand = unknownTopLevelCommand;
+const cli_commands_1 = require("./cli-commands");
+const TOP_LEVEL_COMMANDS = new Set([...cli_commands_1.CLI_COMMANDS, 'flow', 'edit', 'help']);
+const VALUE_FLAGS = new Set([
+    '--root',
+    '--input',
+    '--input-env',
+    '--input-file',
+    '--mode',
+    '--model',
+    '--language',
+    '--conversation',
+    '--args',
+    '--args-file',
+    '--selected',
+    '--models',
+    '--name',
+    '--url',
+    '--key',
+    '--api-key',
+    '--protocol',
+    '--endpoint',
+    '--endpoint-env',
+    '--url-env',
+    '--key-env',
+    '--api-key-env',
+    '--env-file',
+    '--env-file-env',
+    '--claude-env-file',
+    '--claude-env-file-env',
+    '--anthropic-env-file',
+    '--anthropic-env-file-env',
+    '--candidate-models',
+    '--query',
+    '--type',
+    '--target',
+    '--source',
+    '--source-id',
+    '--remove-source',
+    '--enable-source',
+    '--disable-source',
+    '--target-file',
+    '--expected-version',
+    '--preserve',
+    '--repo',
+    '--tag',
+    '--asset',
+    '--path',
+    '--component',
+    '--content-file',
+    '--content',
+    '--description',
+    '--tags',
+    '--workspace',
+    '--remote-debugging-port',
+    '--user-data-dir',
+    '--disable-features',
+    '--enable-features',
+    '--remote-debugging-address',
+    '--inspect-port',
+    '--js-flags',
+    '--viewer-request',
+]);
+const BOOLEAN_FLAGS = new Set([
+    '--tui',
+    '--gui',
+    '--cli',
+    '--server',
+    '--help',
+    '-h',
+    '--version',
+    '-v',
+    '-version',
+    '--automation-wake',
+    '--newmark-viewer',
+    '--allow-multiple-instances',
+    '--disable-gpu',
+    '--no-sandbox',
+    '--no-devtools',
+    '--demo',
+    '--persist',
+    '--agent-only',
+    '--list',
+    '--preview-only',
+    '--sources',
+    '--add-source',
+    '--check-github',
+    '--from-github',
+    '--dry-run',
+    '--read',
+    '--index',
+    '--reindex',
+    '--update',
+    '--folder',
+    '--quiet',
+    '--json',
+    '--limit',
+    '--scopes',
+    '--web',
+]);
+/** Public version spellings accepted by every Newmark entrypoint. */
+function isVersionArgument(args) {
+    return args.some(arg => ['--version', '-v', '-version'].includes(String(arg).toLowerCase()));
+}
+/**
+ * Validate arguments that are interpreted before a command-specific parser is
+ * entered. This keeps malformed launch probes from silently starting a GUI or
+ * falling back to the default user root.
+ */
+function invalidTopLevelArgument(args) {
+    let skipNext = false;
+    for (let index = 0; index < args.length; index++) {
+        const raw = args[index];
+        const arg = String(raw || '');
+        if (skipNext) {
+            skipNext = false;
+            continue;
+        }
+        if (!arg || arg === '--')
+            continue;
+        if (!arg.startsWith('-'))
+            continue;
+        const name = (arg.includes('=') ? arg.slice(0, arg.indexOf('=')) : arg).toLowerCase();
+        const hasInlineValue = arg.includes('=');
+        if (BOOLEAN_FLAGS.has(name))
+            continue;
+        if (VALUE_FLAGS.has(name)) {
+            if (!hasInlineValue) {
+                const next = args[index + 1];
+                if (!next || String(next).startsWith('-'))
+                    return `${name} requires a value`;
+                skipNext = true;
+            }
+            else if (!arg.slice(name.length + 1)) {
+                return `${name} requires a value`;
+            }
+            continue;
+        }
+        return arg;
+    }
+    return undefined;
+}
+/**
+ * Return the first unknown positional top-level token without validating a
+ * command's own arguments. Values belonging to documented flags are skipped,
+ * so a space-containing --root or --input cannot be mistaken for a command.
+ */
+function unknownTopLevelCommand(args) {
+    let skipNext = false;
+    for (let index = 0; index < args.length; index++) {
+        const raw = args[index];
+        const arg = String(raw || '');
+        if (skipNext) {
+            skipNext = false;
+            continue;
+        }
+        if (!arg)
+            continue;
+        if (arg.startsWith('--')) {
+            const name = (arg.includes('=') ? arg.slice(0, arg.indexOf('=')) : arg).toLowerCase();
+            if (VALUE_FLAGS.has(name) && !arg.includes('='))
+                skipNext = true;
+            else if (!VALUE_FLAGS.has(name) && !BOOLEAN_FLAGS.has(name))
+                return arg;
+            continue;
+        }
+        if (arg.startsWith('-')) {
+            if (!BOOLEAN_FLAGS.has(arg))
+                return arg;
+            continue;
+        }
+        if (TOP_LEVEL_COMMANDS.has(arg.toLowerCase()))
+            return undefined;
+        return arg;
+    }
+    return undefined;
+}
+//# sourceMappingURL=cli-discovery.js.map

package/dist/cli-help.d.ts

@@ -0,0 +1,4 @@
+export declare function newmarkFlowHelpText(): string;
+export declare function newmarkEditHelpText(): string;
+export declare function newmarkHelpText(version: string): string;
+//# sourceMappingURL=cli-help.d.ts.map

package/dist/cli-help.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newmarkFlowHelpText = newmarkFlowHelpText;
+exports.newmarkEditHelpText = newmarkEditHelpText;
+exports.newmarkHelpText = newmarkHelpText;
+const cli_commands_1 = require("./cli-commands");
+function newmarkFlowHelpText() {
+    return [
+        'Newmark Flow command:',
+        '',
+        'Usage: Newmark.exe flow <workflow-name> [start-pc] [--input "text"] [--root <dir>]',
+        'Run a saved Flow workflow from the selected local runtime root.',
+        '',
+        'Flags:',
+        '  --help, -h     Show this Flow help and exit without runtime or model work.',
+    ].join('\n') + '\n';
+}
+function newmarkEditHelpText() {
+    return [
+        'Newmark editor command:',
+        '',
+        'Usage: Newmark.exe edit <file.txt|.json|.tex|.md>',
+        'Open a supported text file in the terminal editor.',
+        '',
+        'Flags:',
+        '  --help, -h     Show this editor help and exit without opening a file.',
+    ].join('\n') + '\n';
+}
+function newmarkHelpText(version) {
+    return [
+        `Newmark Agent ${version}`,
+        '',
+        'Usage:',
+        '  Newmark Agent.exe [--gui|--TUI|--cli] [--root <dir>]',
+        '  Newmark.exe <command> ...',
+        '  Newmark.exe flow <workflow-name> [start-pc] [--input "text"] [--root <dir>]',
+        '  Newmark.exe edit <file.txt|.json|.tex|.md>',
+        '',
+        (0, cli_commands_1.cliCommandUsage)(),
+        '',
+        'Flags:',
+        '  --help, -h     Show this help and exit.',
+        '  --version, -v, -version  Show the installed version and exit.',
+    ].join('\n');
+}
+//# sourceMappingURL=cli-help.js.map