@dev-mainsequence/codex-plugin 0.0.0-stage → 0.4.2

package/dist/vendor/devtools/shared/agents.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentClient = void 0;
+exports.isAgentAction = isAgentAction;
+const node_crypto_1 = require("node:crypto");
+const models_1 = require("./models.js");
+const session_1 = require("./session.js");
+const mcpTransport_1 = require("./mcpTransport.js");
+const agentReadiness_1 = require("./agentReadiness.js");
+function isAgentAction(action) {
+    return ['agents-list', 'agent-get', 'agent-session', 'agent-readiness', 'agent-send', 'agent-task-get', 'agent-task-wait', 'agent-task-cancel'].includes(action);
+}
+function uuid(value) {
+    if (typeof value !== 'string' || !/^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/i.test(value)) {
+        throw new models_1.ToolingError('INVALID_REQUEST', 'Choose an agent and organization environment from the directory.');
+    }
+    return value.toLowerCase();
+}
+function text(value, limit = 16000) { return typeof value === 'string' ? value.replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f]/g, '').slice(0, limit) : ''; }
+function agent(row, environmentUid) {
+    if (!row || uuid(row.organization_environment_uid) !== environmentUid)
+        throw new models_1.ToolingError('INVALID_REQUEST', 'This agent belongs to a different environment. Refresh the directory.');
+    if (!text(row.name).trim())
+        throw new models_1.ToolingError('API_ERROR', 'The agent directory returned an unnamed agent.');
+    return { uid: uuid(row.uid), name: text(row.name, 300), description: text(row.description), environmentUid,
+        environmentName: text(row.organization_environment_name, 300), repositoryBranch: text(row.repository_branch, 300),
+        runtimeReleaseUid: row.runtime_release_uid ? uuid(row.runtime_release_uid) : null,
+        runtimeState: text(row.runtime_update?.state, 50) || 'unknown',
+        defaults: { provider: text(row.llm_provider, 64).trim(), model: text(row.llm_model, 128).trim(), thinking: text(row.llm_thinking, 1000).trim() },
+        responseKinds: Array.isArray(row.a2a_profile?.supported_response_kinds) ? row.a2a_profile.supported_response_kinds.filter((value) => value === 'message' || value === 'task') : [],
+        skills: (Array.isArray(row.agent_card?.skills) ? row.agent_card.skills : []).slice(0, 50).map((skill) => ({ name: text(skill.name, 300), description: text(skill.description), examples: (Array.isArray(skill.examples) ? skill.examples : []).slice(0, 10).map((value) => text(value, 2000)) })) };
+}
+/** Host-independent platform Agent client. Never connects to a card's URL or exposes runtime credentials. */
+class AgentClient {
+    session;
+    options;
+    constructor(session, options = {}) {
+        this.session = session;
+        this.options = options;
+    }
+    async dispatch(input, selectedBackend) {
+        let sent = false;
+        let readinessDeadline;
+        try {
+            const backend = (0, session_1.requireBackend)(selectedBackend), environmentUid = uuid(input.environmentUid);
+            this.options.signal?.throwIfAborted();
+            if (!isAgentAction(input.action))
+                throw new models_1.ToolingError('INVALID_REQUEST', 'Unknown agent action.');
+            const identity = await this.session.status(backend, true);
+            if (!identity.authenticated || !identity.username)
+                throw new models_1.ToolingError('NOT_AUTHENTICATED', 'Sign in to MainSequence to use agents.');
+            if (input.expectedAccount !== undefined && input.expectedAccount !== identity.username)
+                throw new models_1.ToolingError('AUTH_REJECTED', 'The MainSequence account changed. Refresh agents and start a new conversation.');
+            if (['agent-session', 'agent-readiness', 'agent-send', 'agent-task-get', 'agent-task-wait', 'agent-task-cancel'].includes(input.action) && !input.expectedAccount) {
+                throw new models_1.ToolingError('INVALID_REQUEST', 'Agent conversations must be bound to the account returned by discovery.');
+            }
+            // The built-in session binds every request/retry to the selected account. Legacy
+            // custom agent transports retain their existing account-check contract.
+            const session = input.expectedAccount !== undefined && this.session.withAccount
+                ? await this.session.withAccount(backend, input.expectedAccount) : this.session;
+            const timeouts = new Map();
+            const client = new mcpTransport_1.McpTransport(message => {
+                const remaining = readinessDeadline === undefined ? undefined : Math.ceil(readinessDeadline - performance.now());
+                if (remaining !== undefined && remaining <= 0)
+                    throw new models_1.ToolingError('PROCESS_TIMEOUT', 'The agent did not become ready in time. No message was sent. Try again.');
+                return session.request(backend, 'POST', '/mcp', message, message.method !== 'tools/call' || !['a2a.send_message', 'a2a.cancel_task'].includes(message.params?.name), remaining !== undefined ? { timeoutMs: Math.min(30000, remaining) }
+                    : message.method === 'tools/call' && timeouts.has(message.params?.name) ? { timeoutMs: timeouts.get(message.params.name) } : undefined);
+            });
+            await client.initialize();
+            const tools = await client.tools();
+            const catalog = new Set(tools.map(tool => tool.name));
+            for (const tool of tools) {
+                const seconds = tool._meta?.['mainsequence.ai/timeout-seconds/v1'];
+                if (typeof seconds === 'number' && Number.isFinite(seconds) && seconds > 0 && seconds <= 295) {
+                    timeouts.set(tool.name, Math.ceil(seconds * 1000) + 5000);
+                }
+            }
+            // Older catalogs omit deadlines. Cover the existing 140-second gateway budget.
+            if (!timeouts.has('a2a.send_message'))
+                timeouts.set('a2a.send_message', 145000);
+            const call = async (name, args, mutation = false) => {
+                if (!catalog.has(name))
+                    throw new models_1.ToolingError('UNSUPPORTED_ACTION', `The connected platform does not offer ${name}.`);
+                this.options.signal?.throwIfAborted();
+                if (mutation)
+                    sent = true;
+                const output = await client.request('tools/call', { name, arguments: args });
+                if (output?.isError) {
+                    const code = text(output.structuredContent?.body?.code, 100).replace(/[^a-zA-Z0-9_-]/g, '');
+                    throw new models_1.ToolingError('API_ERROR', `${name} could not complete${code ? ` (${code})` : ''}. Check agent availability and access. The call was not replayed.`);
+                }
+                if (!output?.structuredContent || typeof output.structuredContent !== 'object')
+                    throw new models_1.ToolingError('API_ERROR', 'The platform returned an invalid agent result.');
+                return output.structuredContent;
+            };
+            let data;
+            if (input.action === 'agents-list') {
+                const limit = input.limit ?? 25, offset = input.offset ?? 0;
+                if (!Number.isInteger(limit) || limit < 1 || limit > 100 || !Number.isInteger(offset) || offset < 0
+                    || (input.search !== undefined && (typeof input.search !== 'string' || input.search.length > 2000)))
+                    throw new models_1.ToolingError('INVALID_REQUEST', 'Search requires text, a limit of 1–100, and a nonnegative offset.');
+                const search = input.search?.trim();
+                const page = search ? await call('agent.search', { organization_environment_uid: environmentUid, q: search, limit })
+                    : await call('agent.list', { organization_environment_uid: environmentUid, limit, offset });
+                if (!Array.isArray(page.results) || (!search && (!Number.isInteger(page.count) || page.count < 0)))
+                    throw new models_1.ToolingError('API_ERROR', 'The platform returned invalid agent pagination.');
+                data = { account: identity.username, results: page.results.map((row) => agent(row, environmentUid)), count: search ? page.results.length : page.count, offset: search ? 0 : offset, semantic: !!search };
+            }
+            else {
+                const agentUid = uuid(input.agentUid);
+                const selected = agent(await call('agent.get', { agent_uid: agentUid }), environmentUid);
+                if (selected.uid !== agentUid)
+                    throw new models_1.ToolingError('API_ERROR', 'The platform returned another agent.');
+                const task = async (taskUid) => {
+                    const result = await call('a2a.get_task', { task_uid: uuid(taskUid) });
+                    if (uuid(result.agent_uid) !== agentUid || uuid(result.task_uid) !== uuid(taskUid))
+                        throw new models_1.ToolingError('INVALID_REQUEST', 'This task belongs to another agent.');
+                    return result;
+                };
+                const resolveSession = async (target) => {
+                    const resolved = await call('agent.get_or_create_session', { agent_uid: agentUid, ...target });
+                    if (uuid(resolved.agent_uid) !== agentUid || uuid(resolved.organization_environment_uid) !== environmentUid
+                        || (target.session_uid && uuid(resolved.uid) !== uuid(target.session_uid))
+                        || (target.handle_unique_id && resolved.bound_handle?.handle_unique_id !== target.handle_unique_id)) {
+                        throw new models_1.ToolingError('API_ERROR', 'The platform returned another agent conversation.');
+                    }
+                    return resolved;
+                };
+                const ready = async (sessionUid, timeoutMs) => {
+                    if (!selected.runtimeReleaseUid || selected.runtimeState === 'not_deployed')
+                        throw new models_1.ToolingError('UNSUPPORTED_ACTION', 'This agent has no deployed runtime.');
+                    try {
+                        await (0, agentReadiness_1.waitForAgentReadiness)({ signal: this.options.signal, progress: this.options.progress, timeoutMs,
+                            resolve: async (deadline) => {
+                                readinessDeadline = deadline;
+                                const account = await this.session.status(backend, true);
+                                if (!account.authenticated || account.username !== identity.username)
+                                    throw new models_1.ToolingError('AUTH_REJECTED', 'The MainSequence account changed while checking the agent. Choose the agent again.');
+                                return call('agent_session.resolve_runtime_access', { agent_session_uid: sessionUid });
+                            } });
+                    }
+                    finally {
+                        readinessDeadline = undefined;
+                    }
+                };
+                if (input.action === 'agent-get')
+                    data = { account: identity.username, agent: selected };
+                else if (input.action === 'agent-readiness') {
+                    const resolved = await resolveSession({ session_uid: uuid(input.sessionUid) });
+                    await ready(uuid(resolved.uid), input.timeoutMs);
+                    data = { account: identity.username, agentUid, sessionUid: uuid(resolved.uid), ready: true };
+                }
+                else if (input.action === 'agent-session') {
+                    if ([input.handleId, input.sessionUid].filter(value => value !== undefined).length !== 1) {
+                        throw new models_1.ToolingError('INVALID_REQUEST', 'Use exactly one conversation handle or session.');
+                    }
+                    let target;
+                    if (input.sessionUid !== undefined)
+                        target = { session_uid: uuid(input.sessionUid) };
+                    else {
+                        if (typeof input.handleId !== 'string' || !/^[-a-zA-Z0-9_]{1,255}$/.test(input.handleId)) {
+                            throw new models_1.ToolingError('INVALID_REQUEST', 'A stable conversation handle is required.');
+                        }
+                        target = { handle_unique_id: input.handleId };
+                    }
+                    const resolved = await resolveSession(target);
+                    data = { account: identity.username, agent: selected, sessionUid: uuid(resolved.uid),
+                        ...(resolved.bound_handle?.handle_unique_id ? { handleId: text(resolved.bound_handle.handle_unique_id, 255) } : {}) };
+                }
+                else if (input.action === 'agent-send') {
+                    if (typeof input.message !== 'string' || !input.message.trim() || input.message.length > 64000)
+                        throw new models_1.ToolingError('INVALID_REQUEST', 'Enter a message of 1–64000 characters.');
+                    if (!['message', 'task'].includes(input.responseKind) || !selected.responseKinds.includes(input.responseKind))
+                        throw new models_1.ToolingError('UNSUPPORTED_ACTION', 'The agent does not advertise the requested response mode.');
+                    if (!selected.runtimeReleaseUid || selected.runtimeState === 'not_deployed')
+                        throw new models_1.ToolingError('UNSUPPORTED_ACTION', 'This agent has no deployed runtime.');
+                    if ([input.handleId, input.sessionUid, input.taskUid].filter(value => value !== undefined).length !== 1)
+                        throw new models_1.ToolingError('INVALID_REQUEST', 'Use exactly one conversation handle, session, or task.');
+                    let target;
+                    if (input.taskUid) {
+                        if (input.responseKind !== 'task')
+                            throw new models_1.ToolingError('INVALID_REQUEST', 'Continue an existing task in task mode.');
+                        await task(input.taskUid);
+                        target = { task_uid: uuid(input.taskUid) };
+                    }
+                    else if (input.sessionUid)
+                        target = { agent_uid: agentUid, agent_session_uid: uuid(input.sessionUid) };
+                    else {
+                        if (typeof input.handleId !== 'string' || !/^[-a-zA-Z0-9_]{1,255}$/.test(input.handleId))
+                            throw new models_1.ToolingError('INVALID_REQUEST', 'A stable conversation handle is required.');
+                        target = { agent_uid: agentUid, handle_unique_id: input.handleId };
+                    }
+                    if (input.waitForReady !== undefined && typeof input.waitForReady !== 'boolean')
+                        throw new models_1.ToolingError('INVALID_REQUEST', 'waitForReady must be a boolean.');
+                    if (input.waitForReady) {
+                        const resolved = await resolveSession(input.taskUid
+                            ? { session_uid: uuid((await task(input.taskUid)).agent_session_uid) }
+                            : input.sessionUid ? { session_uid: uuid(input.sessionUid) } : { handle_unique_id: input.handleId });
+                        await ready(uuid(resolved.uid));
+                    }
+                    const reply = await call('a2a.send_message', { ...target, message: input.message, message_id: (0, node_crypto_1.randomUUID)(), response_kind: input.responseKind,
+                        ...(input.responseKind === 'task' ? { completion_policy: 'poll' } : {}) }, true);
+                    if (uuid(reply.agent_uid) !== agentUid || reply.response_kind !== input.responseKind || (input.sessionUid && uuid(reply.agent_session_uid) !== uuid(input.sessionUid)))
+                        throw new models_1.ToolingError('API_ERROR', 'The agent response does not match this conversation.');
+                    data = { account: identity.username, agent: selected, ...projectReply(reply) };
+                }
+                else {
+                    const previous = await task(input.taskUid);
+                    if (input.afterSequence !== undefined && (!Number.isInteger(input.afterSequence) || input.afterSequence < 0))
+                        throw new models_1.ToolingError('INVALID_REQUEST', 'Task event cursor must be nonnegative.');
+                    const result = input.action === 'agent-task-get' ? previous : await call(input.action === 'agent-task-wait' ? 'a2a.wait_task' : 'a2a.cancel_task', { task_uid: uuid(input.taskUid), ...(input.action === 'agent-task-wait' ? { after_sequence: input.afterSequence ?? previous.event_cursor, timeout_seconds: 15 } : {}) }, input.action === 'agent-task-cancel');
+                    if (uuid(result.agent_uid) !== agentUid || uuid(result.task_uid) !== uuid(input.taskUid))
+                        throw new models_1.ToolingError('API_ERROR', 'The task result does not match the selected agent.');
+                    data = { account: identity.username, agent: selected, ...projectReply(result) };
+                }
+            }
+            return { schemaVersion: 1, action: input.action, status: 'success', summary: input.action === 'agent-send' ? 'Agent response received.' : 'Agent operation completed.', data };
+        }
+        catch (error) {
+            const failure = this.options.signal?.aborted ? new models_1.ToolingError('CANCELLED', 'Agent operation cancelled.')
+                : error instanceof models_1.ToolingError ? error : new models_1.ToolingError('API_ERROR', 'The agent operation could not complete.');
+            return { schemaVersion: 1, action: input.action, status: failure.code === 'CANCELLED' ? 'cancelled' : 'failure', summary: failure.message,
+                error: { code: failure.code, message: failure.message }, ...(sent ? { effects: { state: 'partial-or-uncertain', message: 'The remote agent may have received this request. Do not automatically resend it; inspect its session or task first.' } } : {}) };
+        }
+    }
+}
+exports.AgentClient = AgentClient;
+function projectReply(reply) {
+    const result = { sessionUid: uuid(reply.agent_session_uid), responseKind: reply.response_kind || 'task' };
+    if (reply.response_kind === 'message') {
+        if (typeof reply.message !== 'string' || !reply.message.trim())
+            throw new models_1.ToolingError('API_ERROR', 'The agent returned an empty message.');
+        result.message = text(reply.message, 64000);
+    }
+    else
+        Object.assign(result, { taskUid: uuid(reply.task_uid), status: text(reply.status, 100), terminal: reply.terminal === true,
+            eventCursor: reply.event_cursor, cancellationRequested: reply.cancellation_requested === true,
+            outputs: Array.isArray(reply.outputs) ? reply.outputs : [], events: Array.isArray(reply.events) ? reply.events : [], timedOut: reply.timed_out === true });
+    return result;
+}

package/dist/vendor/devtools/shared/arguments.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HELP = void 0;
+exports.parseArguments = parseArguments;
+exports.tokenizeCommand = tokenizeCommand;
+const node_fs_1 = require("node:fs");
+const models_1 = require("./models.js");
+exports.HELP = `MainSequence developer tooling (Node 22+)
+
+ms-devtools login|logout|refresh-token|auth-status|repositories [--backend URL]
+ms-devtools auth-status [--check] [--backend URL]
+ms-devtools mcp-discover [--search TEXT] [--limit N] [--offset N] [--backend URL]
+ms-devtools mcp-list [--backend URL]
+ms-devtools mcp-add|mcp-remove|mcp-tools --uid RELEASE_UUID [--backend URL]
+ms-devtools mcp-call --uid RELEASE_UUID --tool NAME [--arguments-file JSON_FILE] [--backend URL]
+ms-devtools status|resolve [--path ROOT] [--type python|vite_react] [--backend URL]
+ms-devtools sync [--path ROOT]
+ms-devtools sdk-status|update-sdk|update-agents|install-skills|install|env-cleanup [--path ROOT]
+ms-devtools setup --uid UID --branch BRANCH --base-dir DIR [--install] [--backend URL]
+
+sync refreshes dependency files with the project SDK. Python: uv.lock, the environment and
+requirements.txt. Node: package-lock.json, then npm ci. It does not commit, tag or push:
+review the changes, then commit and push them yourself.
+Project commands also accept --type and --backend. update-sdk and install-skills accept --dry-run.
+All commands accept --json. No command accepts credentials as arguments.
+skills-sync requires MainSequence MCP and reports unsupported.
+open-folder and signed-terminal require a host with those native capabilities.
+In Codex desktop, type /ms, select the ms slash-menu entry, then append COMMAND ... .
+The trusted plugin hook executes the selected command before inference.
+`;
+function parseArguments(argv, cwd = process.cwd()) {
+    if (argv.length === 0 || argv[0] === '--help' || argv[0] === '-h')
+        return { json: argv.includes('--json'), help: true };
+    const action = argv[0];
+    const flags = {};
+    const boolean = new Set(['--json', '--check', '--dry-run', '--install']);
+    const valued = new Set(['--backend', '--path', '--type', '--uid', '--branch', '--base-dir', '--search', '--limit', '--offset', '--tool', '--arguments-file']);
+    for (let i = 1; i < argv.length; i++) {
+        const key = argv[i];
+        if (key === '--help' || key === '-h')
+            return { json: argv.includes('--json'), help: true };
+        if (action === 'sync' && ['--message', '-m', '--dry-run'].includes(key)) {
+            throw new models_1.ToolingError('INVALID_REQUEST', `sync no longer takes ${key}: it refreshes dependency files and does not commit, tag or push. Commit and push the changes yourself.`);
+        }
+        if (key in flags)
+            throw new models_1.ToolingError('INVALID_REQUEST', 'Duplicate command option.');
+        if (boolean.has(key))
+            flags[key] = true;
+        else if (valued.has(key)) {
+            const value = argv[++i];
+            if (value === undefined || !value.trim() || value.includes('\0'))
+                throw new models_1.ToolingError('INVALID_REQUEST', 'A command option is missing its value.');
+            flags[key] = value;
+        }
+        else
+            throw new models_1.ToolingError('INVALID_REQUEST', 'Unknown command option or positional argument. Run --help.');
+    }
+    const global = ['--backend', '--json'];
+    const project = ['--path', '--type'];
+    const allowed = action === 'mcp-discover' ? [...global, '--search', '--limit', '--offset']
+        : action === 'mcp-list' ? global
+            : ['mcp-add', 'mcp-remove', 'mcp-tools'].includes(action) ? [...global, '--uid']
+                : action === 'mcp-call' ? [...global, '--uid', '--tool', '--arguments-file']
+                    : ['login', 'logout', 'refresh-token', 'repositories'].includes(action) ? global
+                        : action === 'auth-status' ? [...global, '--check']
+                            : action === 'setup' ? [...global, '--uid', '--branch', '--base-dir', '--install']
+                                : [...global, ...project, ...(['update-sdk', 'install-skills'].includes(action) ? ['--dry-run'] : [])];
+    if (Object.keys(flags).some(key => !allowed.includes(key)))
+        throw new models_1.ToolingError('INVALID_REQUEST', 'This option does not apply to the selected action.');
+    const backend = typeof flags['--backend'] === 'string' ? flags['--backend'] : undefined;
+    const common = { backend };
+    let request;
+    if (['mcp-discover', 'mcp-list', 'mcp-add', 'mcp-remove', 'mcp-tools', 'mcp-call'].includes(action)) {
+        let args = {};
+        if (typeof flags['--arguments-file'] === 'string') {
+            try {
+                if ((0, node_fs_1.statSync)(flags['--arguments-file']).size > 1_000_000)
+                    throw new Error();
+                args = JSON.parse((0, node_fs_1.readFileSync)(flags['--arguments-file'], 'utf8'));
+                if (!args || typeof args !== 'object' || Array.isArray(args))
+                    throw new Error();
+            }
+            catch {
+                throw new models_1.ToolingError('INVALID_REQUEST', 'The arguments file must contain a JSON object of at most 1 MB.');
+            }
+        }
+        request = { action, ...common, ...(flags['--uid'] ? { releaseUid: flags['--uid'] } : {}),
+            ...(flags['--search'] !== undefined ? { search: flags['--search'] } : {}),
+            ...(flags['--limit'] !== undefined ? { limit: Number(flags['--limit']) } : {}),
+            ...(flags['--offset'] !== undefined ? { offset: Number(flags['--offset']) } : {}),
+            ...(action === 'mcp-call' ? { tool: flags['--tool'], arguments: args } : {}) };
+    }
+    else if (['login', 'logout', 'refresh-token', 'repositories'].includes(action))
+        request = { action, ...common };
+    else if (action === 'auth-status')
+        request = { action, ...common, check: Boolean(flags['--check']) };
+    else if (action === 'setup')
+        request = { action, ...common, repositoryUid: flags['--uid'], branch: flags['--branch'], baseDir: flags['--base-dir'], install: Boolean(flags['--install']) };
+    else
+        request = { action, ...common, root: flags['--path'] || cwd, projectType: flags['--type'], dryRun: Boolean(flags['--dry-run']) };
+    return { request, json: Boolean(flags['--json']) };
+}
+/** Tokenize explicit hook commands without evaluating a shell, substitutions, or expansions. */
+function tokenizeCommand(text) {
+    if (/[\r\n\0]/.test(text))
+        throw new models_1.ToolingError('INVALID_REQUEST', 'MainSequence commands must be a single line.');
+    const words = [];
+    let word = '', quote = '', started = false;
+    for (let i = 0; i < text.length; i++) {
+        const character = text[i];
+        if (quote) {
+            if (character === quote)
+                quote = '';
+            else if (character === '\\' && quote === '"' && ['"', '\\'].includes(text[i + 1]))
+                word += text[++i];
+            else
+                word += character;
+        }
+        else if (character === "'" || character === '"') {
+            quote = character;
+            started = true;
+        }
+        else if (/\s/.test(character)) {
+            if (started) {
+                words.push(word);
+                word = '';
+                started = false;
+            }
+        }
+        else if (';&|<>`'.includes(character))
+            throw new models_1.ToolingError('INVALID_REQUEST', 'Shell operators are not supported in MainSequence commands.');
+        else {
+            word += character;
+            started = true;
+        }
+    }
+    if (quote)
+        throw new models_1.ToolingError('INVALID_REQUEST', 'A command argument has an unclosed quote.');
+    if (started)
+        words.push(word);
+    return words;
+}

package/dist/vendor/devtools/shared/cli.js

@@ -0,0 +1,144 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCodeRepositoryCli = resolveCodeRepositoryCli;
+exports.buildCodeRepositoryCliInvocations = buildCodeRepositoryCliInvocations;
+exports.codeRepositoryActionPreview = codeRepositoryActionPreview;
+exports.sanitizeCommitMessage = sanitizeCommitMessage;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function resolveCodeRepositoryCli(codeRepositoryRoot, codeRepositoryType) {
+    if (codeRepositoryType === 'python') {
+        const executable = process.platform === 'win32'
+            ? path.join(codeRepositoryRoot, '.venv', 'Scripts', 'mainsequence.exe')
+            : path.join(codeRepositoryRoot, '.venv', 'bin', 'mainsequence');
+        return {
+            codeRepositoryType,
+            commandName: 'mainsequence',
+            packageName: 'mainsequence',
+            executable,
+            prefixArgs: [],
+            available: isFile(executable),
+            bootstrapAction: 'buildLocalVenv',
+            bootstrapLabel: 'Build Local .venv',
+            missingMessage: 'The CodeRepository-local mainsequence CLI was not found. Build the local .venv or run uv sync.'
+        };
+    }
+    const packageRoot = path.join(codeRepositoryRoot, 'node_modules', '@dev-mainsequence', 'command-center-sdk');
+    const entrypoint = path.join(packageRoot, 'cli', 'command-center-sdk.mjs');
+    return {
+        codeRepositoryType,
+        commandName: 'command-center-sdk',
+        packageName: '@dev-mainsequence/command-center-sdk',
+        // The installed entry point has a Node shebang on POSIX. Windows needs the
+        // system Node executable because .mjs files are not directly executable.
+        executable: process.execPath,
+        prefixArgs: [entrypoint],
+        available: isFile(entrypoint),
+        bootstrapAction: 'installDependencies',
+        bootstrapLabel: 'Install Dependencies',
+        missingMessage: 'The CodeRepository-local command-center-sdk CLI was not found. Run npm ci in the repository root.'
+    };
+}
+function buildCodeRepositoryCliInvocations(cli, action, 
+/** @deprecated `commitMessage` is ignored: sync takes no commit message. */
+_options = {}) {
+    if (!cli.available)
+        return [];
+    const args = [];
+    if (action === 'sdkStatus' && cli.codeRepositoryType === 'vite_react') {
+        args.push(['application', 'sdk-status', '--path', '.', '--json']);
+    }
+    if (action === 'updateSdk') {
+        args.push(cli.codeRepositoryType === 'python'
+            ? ['code-repository', 'update-sdk', '--path', '.']
+            : ['application', 'update-sdk', '--path', '.']);
+    }
+    if (action === 'sync') {
+        // Python: uv lock, uv sync and the locked requirements.txt export. Node: package-lock.json and npm ci.
+        // No commit message, Git command or backend request; the person commits and pushes.
+        args.push(['code-repository', 'sync', '--path', '.']);
+    }
+    if (action === 'skills') {
+        if (cli.codeRepositoryType === 'python') {
+            args.push(['code-repository', 'update-agent-skills', '--path', '.'], ['code-repository', 'update', 'AGENTS.md', '--path', '.']);
+        }
+        else {
+            args.push(['skills', 'sync', '--path', '.']);
+        }
+    }
+    return args.map((commandArgs) => ({
+        executable: cli.executable,
+        args: [...cli.prefixArgs, ...commandArgs],
+        display: formatDisplayCommand(cli.commandName, commandArgs)
+    }));
+}
+function codeRepositoryActionPreview(codeRepositoryType, action, 
+/** @deprecated Ignored: sync takes no commit message. */
+_commitMessage) {
+    const commandName = codeRepositoryType === 'python' ? 'mainsequence' : 'command-center-sdk';
+    const fakeCli = {
+        codeRepositoryType,
+        commandName,
+        packageName: codeRepositoryType === 'python' ? 'mainsequence' : '@dev-mainsequence/command-center-sdk',
+        executable: commandName,
+        prefixArgs: [],
+        available: true,
+        bootstrapAction: codeRepositoryType === 'python' ? 'buildLocalVenv' : 'installDependencies',
+        bootstrapLabel: codeRepositoryType === 'python' ? 'Build Local .venv' : 'Install Dependencies',
+        missingMessage: ''
+    };
+    return buildCodeRepositoryCliInvocations(fakeCli, action).map(item => item.display);
+}
+/** @deprecated Sync takes no commit message. Kept for existing callers; nothing in this package uses it. */
+function sanitizeCommitMessage(message) {
+    return String(message || '').replace(/[\r\n]+/g, ' ').trim();
+}
+function formatDisplayCommand(command, args) {
+    return [command, ...args].map(quoteDisplayArgument).join(' ');
+}
+function quoteDisplayArgument(value) {
+    if (/^[A-Za-z0-9_./:@+-]+$/.test(value))
+        return value;
+    return JSON.stringify(value);
+}
+function isFile(value) {
+    try {
+        return fs.statSync(value).isFile();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/vendor/devtools/shared/config.js

@@ -0,0 +1,64 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeBackendUrl = normalizeBackendUrl;
+const net = __importStar(require("net"));
+function normalizeBackendUrl(input) {
+    const raw = String(input || '').trim();
+    if (!raw)
+        return '';
+    if (raw.includes('://'))
+        return raw.replace(/\/+$/, '');
+    const host = raw.split('/', 1)[0].split(':', 1)[0].replace(/^\[|\]$/g, '').toLowerCase();
+    const localHost = host === 'localhost' || host === '0.0.0.0' || isPrivateIp(host);
+    return `${localHost ? 'http' : 'https'}://${raw}`.replace(/\/+$/, '');
+}
+function isPrivateIp(host) {
+    const kind = net.isIP(host);
+    if (kind === 4) {
+        const parts = host.split('.').map(Number);
+        return parts[0] === 0 || parts[0] === 10 || parts[0] === 127 ||
+            (parts[0] === 169 && parts[1] === 254) ||
+            (parts[0] === 172 && parts[1] >= 16 && parts[1] <= 31) ||
+            (parts[0] === 192 && parts[1] === 168);
+    }
+    if (kind === 6) {
+        const normalized = host.toLowerCase();
+        return normalized === '::' || normalized === '::1' || normalized.startsWith('fc') ||
+            normalized.startsWith('fd') || normalized.startsWith('fe8') || normalized.startsWith('fe9') ||
+            normalized.startsWith('fea') || normalized.startsWith('feb');
+    }
+    return false;
+}