@dev-mainsequence/codex-plugin 0.3.0 → 0.7.9

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

@@ -0,0 +1,506 @@
+"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.createSharedTransport = createSharedTransport;
+/** Opt-in, per-user HTTP owner for desktop hosts with one process per chat.
+ * Credentials and cached responses stay in memory. The private Unix socket is
+ * local IPC, not a new login, backend, public listener, or autonomous poller.
+ */
+const net = __importStar(require("node:net"));
+const http = __importStar(require("node:http"));
+const https = __importStar(require("node:https"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const node_crypto_1 = require("node:crypto");
+const node_child_process_1 = require("node:child_process");
+const node_stream_1 = require("node:stream");
+const mcpTransport_1 = require("./mcpTransport.js");
+const PROTOCOL = 2, MAX_BYTES = 8_000_000, MAX_FRAME = 12_000_000;
+const unavailable = () => new Error('Shared MainSequence transport disconnected. No request was replayed. Read the saved operation receipt before recovery.');
+const hash = (input) => (0, node_crypto_1.createHash)('sha256').update(input).digest('hex');
+function headerPairs(headers) { const pairs = []; headers.forEach((value, key) => pairs.push([key, value])); return pairs; }
+function privateDirectory(directory) {
+    fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const stat = fs.lstatSync(directory);
+    if (!stat.isDirectory() || stat.isSymbolicLink() || stat.uid !== process.getuid?.() || (stat.mode & 0o077))
+        throw new Error('Shared transport requires a private directory owned by the current user.');
+}
+function frames(socket, receive) {
+    let buffer = '';
+    socket.setEncoding('utf8');
+    socket.on('data', chunk => {
+        buffer += chunk;
+        if (buffer.length > MAX_FRAME) {
+            socket.destroy();
+            return;
+        }
+        let end;
+        while ((end = buffer.indexOf('\n')) >= 0) {
+            const line = buffer.slice(0, end);
+            buffer = buffer.slice(end + 1);
+            try {
+                receive(JSON.parse(line));
+            }
+            catch {
+                socket.destroy();
+                return;
+            }
+        }
+    });
+}
+/** All participating processes share one owner. No fallback creates a private pool. */
+function createSharedTransport(options = {}) {
+    if (process.platform === 'win32')
+        throw new Error('Shared MainSequence transport currently requires Unix-domain sockets.');
+    const directory = options.directory ?? path.join(os.tmpdir(), `ms-http-v${PROTOCOL}-${process.getuid()}-${hash(os.homedir()).slice(0, 12)}`);
+    const socketPath = path.join(directory, 'transport.sock');
+    // Capture the worker and its two internal dependencies now. Codex can remove
+    // this installation while a chat is alive; a later reconnect still works.
+    const modules = Object.fromEntries(['sharedTransport', 'mcpTransport', 'models'].map(name => [name, fs.readFileSync(path.join(__dirname, name + '.js'), 'utf8')]));
+    const workerSource = `const sources=${JSON.stringify(modules)},cache={};function load(name){if(cache[name])return cache[name].exports;const m={exports:{}};cache[name]=m;const r=id=>id.startsWith('./')?load(id.slice(2).replace(/\\.js$/,'')):require(id);r.main=name==='sharedTransport'?m:null;new Function('require','module','exports','__filename','__dirname',sources[name])(r,m,m.exports,'sharedTransport.js','.');return m.exports;}process.argv=['node','worker','--shared-http-worker',${JSON.stringify(directory)}];load('sharedTransport');`;
+    let socket, connecting, closed = false;
+    const pending = new Map();
+    async function connect() {
+        if (closed)
+            throw unavailable();
+        if (socket && !socket.destroyed)
+            return socket;
+        if (connecting)
+            return connecting;
+        connecting = (async () => {
+            privateDirectory(directory);
+            const attempt = () => new Promise((resolve, reject) => {
+                const next = net.createConnection(socketPath);
+                next.once('error', reject);
+                next.once('connect', () => { next.removeListener('error', reject); resolve(next); });
+            });
+            let next;
+            try {
+                next = await attempt();
+            }
+            catch {
+                // The worker takes an exclusive lock before listening; concurrent clients
+                // may start contenders but only one can own the upstream connection pool.
+                const worker = (0, node_child_process_1.spawn)(process.execPath, ['-'], { cwd: os.homedir(), detached: true, stdio: ['pipe', 'ignore', 'ignore'], env: { PATH: process.env.PATH, HOME: os.homedir() } });
+                worker.stdin.on('error', () => { });
+                worker.stdin.end(workerSource);
+                worker.on('error', () => { });
+                worker.unref();
+                for (let n = 0; n < 100 && !next; n++) {
+                    await new Promise(resolve => setTimeout(resolve, 30));
+                    try {
+                        next = await attempt();
+                    }
+                    catch { /* startup, not an HTTP replay */ }
+                }
+            }
+            if (!next)
+                throw unavailable();
+            if (closed) {
+                next.destroy();
+                throw unavailable();
+            }
+            socket = next;
+            next.on('error', () => { });
+            next.on('close', () => { if (socket === next)
+                socket = undefined; for (const task of pending.values())
+                task.reject(unavailable()); pending.clear(); });
+            frames(next, message => {
+                const task = pending.get(message.id);
+                if (!task)
+                    return;
+                pending.delete(message.id);
+                if (!pending.size)
+                    next.unref();
+                if (message.error)
+                    task.reject(new Error(message.error));
+                else
+                    task.resolve(message.result);
+            });
+            next.unref();
+            return next;
+        })().finally(() => { connecting = undefined; });
+        return connecting;
+    }
+    async function rpc(op, request, signal) {
+        signal?.throwIfAborted();
+        const connection = await connect();
+        signal?.throwIfAborted();
+        const id = (0, node_crypto_1.randomUUID)();
+        return new Promise((resolve, reject) => {
+            const abort = () => { pending.delete(id); connection.write(JSON.stringify({ op: 'cancel', id }) + '\n'); if (!pending.size)
+                connection.unref(); reject(signal?.reason ?? unavailable()); };
+            pending.set(id, { resolve: value => { signal?.removeEventListener('abort', abort); resolve(value); }, reject: error => { signal?.removeEventListener('abort', abort); reject(error); } });
+            signal?.addEventListener('abort', abort, { once: true });
+            connection.ref();
+            connection.write(JSON.stringify({ id, op, request }) + '\n');
+        });
+    }
+    const transport = async (input, init = {}) => {
+        if (input instanceof Request || (init.body !== undefined && init.body !== null && typeof init.body !== 'string'))
+            throw new Error('Shared transport accepts URL requests with optional text bodies.');
+        const request = { url: String(input), method: init.method ?? 'GET', headers: headerPairs(new Headers(init.headers)),
+            ...(typeof init.body === 'string' ? { body: init.body } : {}), read: init.cache === 'force-cache', fresh: init.cache === 'reload' };
+        const value = await rpc('fetch', request, init.signal);
+        return new Response([204, 205, 304].includes(value.status) ? null : Buffer.from(value.body, 'base64'), { status: value.status, headers: value.headers });
+    };
+    const sessionLock = async (backend, run, signal) => {
+        const key = hash(backend), lease = await rpc('acquire', { key }, signal);
+        try {
+            signal?.throwIfAborted();
+            return await run();
+        }
+        finally {
+            await rpc('release', { key, lease }).catch(() => { });
+        }
+    };
+    return { fetch: transport, sessionLock, status: () => rpc('status'), invalidate: () => rpc('invalidate'), close() { closed = true; socket?.destroy(); } };
+}
+function cacheTtl(request) {
+    const url = new URL(request.url);
+    if (request.method === 'POST')
+        return request.read ? 30_000 : 0;
+    if (request.method !== 'GET')
+        return 0;
+    if (url.pathname === '/api/v1/users/me/')
+        return 5_000;
+    if (/^\/api\/v1\/command-center\/agents\/[a-f0-9-]+\/icon\/$/.test(url.pathname))
+        return 300_000;
+    if (/^\/api\/v1\/(organization-environments|command-center\/agents|code-repositories|code-repository-branches|organization-projects)\//.test(url.pathname))
+        return 30_000;
+    return 0;
+}
+function readKey(request) {
+    // IDs are transport correlation only; share reads and restore each caller's ID.
+    let body = request.body;
+    if (request.read && body) {
+        const value = JSON.parse(body);
+        delete value.id;
+        body = JSON.stringify(value);
+    }
+    return hash(JSON.stringify([request.url, request.method, [...request.headers].sort(), body]));
+}
+function responseFor(value, request) {
+    if (!request.read || !request.body || value.status !== 200)
+        return value;
+    const body = JSON.parse(request.body);
+    if (!Object.hasOwn(body, 'id'))
+        return value;
+    const response = JSON.parse(Buffer.from(value.body, 'base64').toString());
+    return { ...value, body: Buffer.from(JSON.stringify({ ...response, id: body.id })).toString('base64') };
+}
+async function runWorker(directory) {
+    privateDirectory(directory);
+    const lock = path.join(directory, 'owner.json'), socketPath = path.join(directory, 'transport.sock');
+    try {
+        fs.writeFileSync(lock, JSON.stringify({ pid: process.pid }), { flag: 'wx', mode: 0o600 });
+    }
+    catch {
+        try {
+            const owner = JSON.parse(fs.readFileSync(lock, 'utf8'));
+            process.kill(owner.pid, 0);
+            return;
+        }
+        catch (error) {
+            if (error.code !== 'ESRCH')
+                return;
+            // Serialize stale recovery too; never unlink another contender's new lock.
+            const recovery = path.join(directory, 'recover.lock');
+            let fd;
+            try {
+                fd = fs.openSync(recovery, 'wx', 0o600);
+            }
+            catch {
+                return;
+            }
+            try {
+                const owner = JSON.parse(fs.readFileSync(lock, 'utf8'));
+                try {
+                    process.kill(owner.pid, 0);
+                    return;
+                }
+                catch (e) {
+                    if (e.code !== 'ESRCH')
+                        return;
+                }
+                fs.unlinkSync(lock);
+            }
+            finally {
+                fs.closeSync(fd);
+                fs.unlinkSync(recovery);
+            }
+            return runWorker(directory);
+        }
+    }
+    const httpAgent = new http.Agent({ keepAlive: true, maxSockets: 2, maxTotalSockets: 8, maxFreeSockets: 2 });
+    const httpsAgent = new https.Agent({ keepAlive: true, maxSockets: 2, maxTotalSockets: 8, maxFreeSockets: 2 });
+    const sockets = new Set(), cache = new Map();
+    const jobs = new Map();
+    let epoch = 0, requests = 0, cacheHits = 0, coalesced = 0, bytes = 0;
+    const instanceId = (0, node_crypto_1.randomUUID)(), invalidate = () => { epoch++; cache.clear(); bytes = 0; };
+    const leases = new Map();
+    function grant(key) { const first = leases.get(key)?.[0]; if (first)
+        send(first.socket, first.id, first.token);
+    else
+        leases.delete(key); }
+    function releaseFor(socket, id) {
+        for (const [key, queue] of leases) {
+            const first = queue[0];
+            const keep = queue.filter(lease => lease.socket !== socket || id && lease.id !== id);
+            leases.set(key, keep);
+            if (keep[0] !== first)
+                grant(key);
+        }
+    }
+    const upstream = async (request, signal) => {
+        requests++;
+        const url = new URL(request.url);
+        const response = await new Promise((resolve, reject) => {
+            const call = (url.protocol === 'https:' ? https : http).request(url, { method: request.method, headers: Object.fromEntries(request.headers),
+                agent: url.protocol === 'https:' ? httpsAgent : httpAgent, signal, timeout: 300_000 }, result => {
+                const headers = new Headers();
+                for (const [key, value] of Object.entries(result.headers))
+                    if (value !== undefined)
+                        headers.set(key, Array.isArray(value) ? value.join(', ') : value);
+                resolve(new Response([204, 205, 304].includes(result.statusCode) ? null : node_stream_1.Readable.toWeb(result), { status: result.statusCode, headers }));
+                if ([204, 205, 304].includes(result.statusCode))
+                    result.resume();
+            });
+            call.on('timeout', () => call.destroy(new Error('HTTP timeout')));
+            call.on('error', reject);
+            call.end(request.body);
+        });
+        const headers = headerPairs(response.headers);
+        if (request.method === 'POST' && /json|event-stream/.test(response.headers.get('content-type') ?? '') && request.body && response.ok) {
+            let message;
+            try {
+                message = JSON.parse(request.body);
+            }
+            catch { /* regular POST */ }
+            if (message?.jsonrpc === '2.0') {
+                const body = await (0, mcpTransport_1.readMcpResponse)(response, message);
+                return { status: response.status, headers: headers.filter(([key]) => !['content-type', 'content-length', 'content-encoding'].includes(key)).concat([['content-type', 'application/json']]), body: body === undefined ? '' : Buffer.from(JSON.stringify(body)).toString('base64') };
+            }
+        }
+        const reader = response.body?.getReader();
+        let size = 0;
+        const parts = [];
+        if (reader)
+            try {
+                while (true) {
+                    const next = await reader.read();
+                    if (next.done)
+                        break;
+                    size += next.value.length;
+                    if (size > MAX_BYTES)
+                        throw new Error('Response size exceeded');
+                    parts.push(Buffer.from(next.value));
+                }
+            }
+            finally {
+                await reader.cancel().catch(() => { });
+            }
+        return { status: response.status, headers, body: Buffer.concat(parts).toString('base64') };
+    };
+    function send(socket, id, result, error) { if (!socket.destroyed)
+        socket.write(JSON.stringify({ id, ...(error ? { error } : { result }) }) + '\n'); }
+    const server = net.createServer(socket => {
+        sockets.add(socket);
+        const identity = (0, node_crypto_1.randomUUID)();
+        socket.on('error', () => { });
+        const detach = (id) => { for (const job of jobs.values()) {
+            for (const [key, listener] of job.listeners)
+                if (listener.socket === socket && (!id || listener.id === id))
+                    job.listeners.delete(key);
+            if (!job.listeners.size)
+                job.controller.abort();
+        } };
+        socket.on('close', () => { sockets.delete(socket); detach(); releaseFor(socket); });
+        frames(socket, message => {
+            const id = message.id;
+            if (typeof id !== 'string' || id.length > 100) {
+                socket.destroy();
+                return;
+            }
+            if (message.op === 'cancel') {
+                detach(id);
+                releaseFor(socket, id);
+                return;
+            }
+            if (message.op === 'acquire' || message.op === 'release') {
+                const key = message.request?.key;
+                if (typeof key !== 'string' || !/^[a-f0-9]{64}$/.test(key)) {
+                    socket.destroy();
+                    return;
+                }
+                const queue = leases.get(key) || [];
+                if (message.op === 'acquire') {
+                    if (queue.length >= 256) {
+                        send(socket, id, undefined, 'Too many pending session operations.');
+                        return;
+                    }
+                    queue.push({ socket, id, token: (0, node_crypto_1.randomUUID)() });
+                    leases.set(key, queue);
+                    if (queue.length === 1)
+                        grant(key);
+                }
+                else {
+                    if (queue[0]?.socket === socket && queue[0].token === message.request.lease) {
+                        queue.shift();
+                        grant(key);
+                    }
+                    send(socket, id);
+                }
+                return;
+            }
+            if (message.op === 'invalidate') {
+                invalidate();
+                send(socket, id);
+                return;
+            }
+            if (message.op === 'status') {
+                const count = (agent) => [...Object.values(agent.sockets), ...Object.values(agent.freeSockets)].reduce((sum, values) => sum + (values?.length || 0), 0);
+                send(socket, id, { protocol: PROTOCOL, instanceId, pid: process.pid, clients: sockets.size, requests, cacheHits, coalesced, active: jobs.size, connections: count(httpAgent) + count(httpsAgent), maxConnectionsPerOrigin: 2 });
+                return;
+            }
+            if (message.op !== 'fetch' || jobs.size >= 256) {
+                send(socket, id, undefined, 'Shared transport is busy or the operation is unsupported.');
+                return;
+            }
+            const request = message.request;
+            let url;
+            try {
+                url = new URL(request.url);
+            }
+            catch {
+                socket.destroy();
+                return;
+            }
+            if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || !['GET', 'POST'].includes(request.method) || !Array.isArray(request.headers) || (request.body && Buffer.byteLength(request.body) > 1_000_000)) {
+                socket.destroy();
+                return;
+            }
+            const renewal = request.method === 'POST' && url.pathname === '/auth/jwt-token/token/refresh/';
+            const read = request.method === 'GET' || request.read || renewal, key = read ? readKey(request) : (0, node_crypto_1.randomUUID)();
+            if (!read || request.fresh)
+                invalidate();
+            const flightKey = epoch + ':' + key;
+            const found = cache.get(key);
+            if (found && found.until > Date.now()) {
+                cacheHits++;
+                send(socket, id, responseFor(found.value, request));
+                return;
+            }
+            if (found) {
+                bytes -= found.value.body.length;
+                cache.delete(key);
+            }
+            let job = jobs.get(flightKey);
+            if (job?.controller.signal.aborted)
+                job = undefined;
+            if (job)
+                coalesced++;
+            else {
+                const controller = new AbortController(), startedEpoch = epoch;
+                job = { controller, listeners: new Map(), promise: upstream(request, controller.signal) };
+                jobs.set(flightKey, job);
+                const owned = job;
+                void owned.promise.then(value => {
+                    if (!read || value.status === 401 || value.status === 403)
+                        invalidate();
+                    let ttl = cacheTtl(request);
+                    const auth = request.headers.find(([name]) => name === 'authorization')?.[1];
+                    try {
+                        const exp = JSON.parse(Buffer.from(auth.split('.')[1], 'base64url').toString()).exp;
+                        if (typeof exp === 'number')
+                            ttl = Math.min(ttl, exp * 1000 - Date.now() - 5000);
+                    }
+                    catch { /* opaque token: bounded TTL */ }
+                    let success = value.status >= 200 && value.status < 300;
+                    if (request.read && value.body) {
+                        try {
+                            const result = JSON.parse(Buffer.from(value.body, 'base64').toString());
+                            success = success && !result.error && !result.result?.isError;
+                        }
+                        catch {
+                            success = false;
+                        }
+                    }
+                    if (success && ttl > 0 && epoch === startedEpoch && !controller.signal.aborted) {
+                        while (cache.size >= 256 || bytes + value.body.length > 24_000_000) {
+                            const oldest = cache.keys().next().value;
+                            if (!oldest)
+                                break;
+                            bytes -= cache.get(oldest).value.body.length;
+                            cache.delete(oldest);
+                        }
+                        cache.set(key, { value, until: Date.now() + ttl, epoch });
+                        bytes += value.body.length;
+                    }
+                    for (const listener of owned.listeners.values())
+                        send(listener.socket, listener.id, responseFor(value, listener.request));
+                }, () => { if (!read)
+                    invalidate(); for (const listener of owned.listeners.values())
+                    send(listener.socket, listener.id, undefined, 'MainSequence HTTP request failed. It was not replayed.'); }).finally(() => { if (jobs.get(flightKey) === owned)
+                    jobs.delete(flightKey); });
+            }
+            job.listeners.set(identity + id, { socket, id, request });
+        });
+    });
+    const cleanup = () => { for (const job of jobs.values())
+        job.controller.abort(); httpAgent.destroy(); httpsAgent.destroy(); server.close(); try {
+        fs.unlinkSync(socketPath);
+        fs.unlinkSync(lock);
+    }
+    catch { /* already cleaned */ } };
+    for (const signal of ['SIGINT', 'SIGTERM'])
+        process.once(signal, () => { cleanup(); process.exit(0); });
+    try {
+        fs.unlinkSync(socketPath);
+    }
+    catch { /* first launch */ }
+    server.on('error', () => { cleanup(); process.exitCode = 1; });
+    server.listen(socketPath, () => fs.chmodSync(socketPath, 0o600));
+    let idleSince = Date.now();
+    setInterval(() => { if (sockets.size || jobs.size)
+        idleSince = Date.now();
+    else if (Date.now() - idleSince > 30_000) {
+        cleanup();
+        process.exit(0);
+    } }, 1000).unref();
+}
+if (require.main === module && process.argv[2] === '--shared-http-worker')
+    void runWorker(process.argv[3]).catch(() => { process.exitCode = 1; });

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

@@ -0,0 +1,44 @@
+"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.mainSequenceStateDirectory = mainSequenceStateDirectory;
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+/** The one place that knows where shared MainSequence CLI state lives: the SDKs' configuration,
+ * the saved MCP connections and the project tool catalog (ADR 0004). */
+function mainSequenceStateDirectory(env = process.env, home = os.homedir()) {
+    return process.platform === 'darwin' ? path.join(home, 'Library', 'Application Support', 'MainSequenceCLI')
+        : process.platform === 'win32' ? path.join(env.APPDATA || home, 'MainSequenceCLI') : path.join(home, '.config', 'mainsequence');
+}

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.currentDirectory = currentDirectory;
+const models_1 = require("./models.js");
+/** Only consult the working directory for actions that actually need a project. */
+function currentDirectory() {
+    try {
+        return process.cwd();
+    }
+    catch {
+        throw new models_1.ToolingError('CURRENT_DIRECTORY_UNAVAILABLE', 'The working directory is no longer available. Change to an existing directory or reload the plugin host; for MCP actions, pass an explicit backend.');
+    }
+}

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

@@ -0,0 +1,96 @@
+"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.readDesktopPreferences = readDesktopPreferences;
+exports.writeWorkspacePreferences = writeWorkspacePreferences;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const node_crypto_1 = require("node:crypto");
+const models_1 = require("./models.js");
+const session_1 = require("./session.js");
+const repositories_1 = require("./repositories.js");
+function location(options) {
+    const home = options.homeDir ?? os.homedir(), env = options.env ?? process.env;
+    return options.configPath ?? path.join(process.platform === 'darwin' ? path.join(home, 'Library', 'Application Support', 'MainSequenceCLI') : process.platform === 'win32' ? path.join(env.APPDATA || home, 'MainSequenceCLI') : path.join(home, '.config', 'mainsequence'), 'config.json');
+}
+async function read(file) {
+    try {
+        const stat = await fs.lstat(file);
+        if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 1000000)
+            throw Error();
+        const value = JSON.parse(await fs.readFile(file, 'utf8'));
+        if (!value || Array.isArray(value) || typeof value !== 'object')
+            throw Error();
+        return value;
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return {};
+        throw new models_1.ToolingError('STORE_ERROR', 'Workspace settings could not be read safely. Existing settings were preserved.');
+    }
+}
+async function readDesktopPreferences(options = {}) {
+    const config = await read(location(options));
+    return { ...await (0, repositories_1.readWorkspacePreferences)(options), commandCenterUrl: typeof config.command_center_url === 'string' ? config.command_center_url : '' };
+}
+/** Updates only non-secret workspace fields, preserving existing CLI settings. */
+async function writeWorkspacePreferences(input, options = {}) {
+    const backend = (0, session_1.requireBackend)(input.backend);
+    if (!path.isAbsolute(input.baseDir) || /[\0\r\n]/.test(input.baseDir))
+        throw new models_1.ToolingError('INVALID_REQUEST', 'Repositories folder must be an absolute path.');
+    const commandCenterUrl = input.commandCenterUrl ? (0, session_1.requireBackend)(input.commandCenterUrl) : '';
+    const file = location(options);
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    let lock;
+    try {
+        lock = await fs.open(file + '.preferences.lock', 'wx', 0o600);
+    }
+    catch {
+        throw new models_1.ToolingError('PROJECT_BUSY', 'Another settings update is in progress. Try again after it finishes.');
+    }
+    const temporary = file + '.' + (0, node_crypto_1.randomUUID)() + '.tmp';
+    try {
+        const config = await read(file);
+        await fs.writeFile(temporary, JSON.stringify({ ...config, backend_url: backend, mainsequence_path: path.resolve(input.baseDir), command_center_url: commandCenterUrl }, null, 2) + '\n', { flag: 'wx', mode: 0o600 });
+        await fs.rename(temporary, file);
+        return readDesktopPreferences(options);
+    }
+    finally {
+        await fs.rm(temporary, { force: true });
+        await lock.close();
+        await fs.unlink(file + '.preferences.lock');
+    }
+}