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

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

@@ -0,0 +1,300 @@
+"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.readOrganizationProjectWorkspace = readOrganizationProjectWorkspace;
+exports.setupOrganizationProject = setupOrganizationProject;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const models_1 = require("./models.js");
+const organizationProjects_1 = require("./organizationProjects.js");
+const repositories_1 = require("./repositories.js");
+const projects_1 = require("./projects.js");
+const repositoryIdentity_1 = require("./repositoryIdentity.js");
+const session_1 = require("./session.js");
+function workspaceName(name) {
+    // Claude displays the folder basename. Keep the actual name, including case and spaces.
+    if (!name || name.trim() !== name || /[<>:"/\\|?*\x00-\x1f]/.test(name) || /[. ]$/.test(name)
+        || name === '.' || name === '..' || /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(name)
+        || Buffer.byteLength(name) > 200 || ['repositories', '.mainsequence-project.json'].includes(name.toLowerCase())) {
+        throw new models_1.ToolingError('INVALID_REQUEST', 'The project name must be usable as a local folder name. Rename the project before setting it up.');
+    }
+    return name;
+}
+async function readManifest(file) {
+    const stat = await fs.lstat(file);
+    if (!stat.isFile() || stat.isSymbolicLink())
+        throw new models_1.ToolingError('INVALID_REQUEST', 'The project workspace manifest must be an ordinary file.');
+    try {
+        return JSON.parse(await fs.readFile(file, 'utf8'));
+    }
+    catch {
+        throw new models_1.ToolingError('INVALID_REQUEST', 'The project workspace manifest is unreadable.');
+    }
+}
+/** Read prepared membership, not a claim that any running Claude session has attached it. */
+async function readOrganizationProjectWorkspace(root) {
+    if (!path.isAbsolute(root))
+        throw new models_1.ToolingError('INVALID_REQUEST', 'Choose an absolute project workspace folder.');
+    root = path.resolve(root);
+    await ordinaryDirectory(root);
+    const manifest = await readManifest(path.join(root, '.mainsequence-project.json'));
+    const container = path.dirname(root);
+    const canonical = await readManifest(path.join(container, '.mainsequence-project.json'));
+    if (manifest.schemaVersion !== 2 || manifest.status !== 'ready' || manifest.root !== root
+        || path.basename(root) !== workspaceName(manifest.name) || JSON.stringify(manifest) !== JSON.stringify(canonical)
+        || !Array.isArray(manifest.repositories) || !manifest.repositories.length) {
+        throw new models_1.ToolingError('INVALID_REQUEST', 'Set up this project again before opening its workspace.');
+    }
+    (0, organizationProjects_1.projectUid)(manifest.projectUid);
+    (0, organizationProjects_1.projectUid)(manifest.environmentUid);
+    (0, session_1.requireBackend)(manifest.backend);
+    const paths = new Set(), branches = new Set();
+    for (const row of manifest.repositories) {
+        (0, organizationProjects_1.projectUid)(row.repositoryUid);
+        (0, organizationProjects_1.projectUid)(row.branchUid);
+        const relative = typeof row.path === 'string' ? path.relative(path.join(container, 'repositories'), row.path) : '';
+        if (!relative || relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)
+            || !path.isAbsolute(row.path) || paths.has(row.path) || branches.has(row.branchUid)
+            || typeof row.branch !== 'string' || !row.branch || /[\r\n\0]/.test(row.branch)) {
+            throw new models_1.ToolingError('INVALID_REQUEST', 'The project repository membership is invalid. Set up this project again.');
+        }
+        paths.add(row.path);
+        branches.add(row.branchUid);
+        await ordinaryDirectory(row.path);
+        await ordinaryDirectory(path.join(row.path, '.git'));
+        if (!await exists(path.join(row.path, '.git')))
+            throw new models_1.ToolingError('INVALID_REQUEST', 'A project checkout is missing. Set up this project again.');
+    }
+    const url = new URL('claude://code/new');
+    url.searchParams.set('folder', root);
+    return { root, name: manifest.name, backend: manifest.backend, projectUid: manifest.projectUid,
+        environmentUid: manifest.environmentUid, repositories: manifest.repositories, claudeUrl: url.href };
+}
+async function exists(file) { return fs.lstat(file).then(() => true).catch((error) => { if (error.code === 'ENOENT')
+    return false; throw error; }); }
+async function ordinaryDirectory(directory, create = false) {
+    const resolved = path.resolve(directory), parent = path.dirname(resolved);
+    if (parent !== resolved)
+        await ordinaryDirectory(parent, create);
+    const stat = await fs.lstat(resolved).catch((error) => { if (error.code === 'ENOENT')
+        return undefined; throw error; });
+    if (stat && (!stat.isDirectory() || stat.isSymbolicLink()))
+        throw new models_1.ToolingError('INVALID_REQUEST', `Use ordinary directories for the project workspace: ${resolved}`);
+    if (!stat && create) {
+        await fs.mkdir(resolved).catch((error) => { if (error.code !== 'EEXIST')
+            throw error; });
+        await ordinaryDirectory(resolved);
+    }
+}
+async function atomicJson(file, value) {
+    const temp = `${file}.${(0, node_crypto_1.randomUUID)()}.tmp`;
+    try {
+        await fs.writeFile(temp, JSON.stringify(value, null, 2) + '\n', { flag: 'wx', mode: 0o600 });
+        await fs.rename(temp, file);
+    }
+    finally {
+        await fs.rm(temp, { force: true });
+    }
+}
+async function namedDirectory(parent, name, uid) {
+    await ordinaryDirectory(parent);
+    const names = await exists(parent) ? (await fs.readdir(parent)).filter(value => value === uid || value.endsWith(`-${uid}`)) : [];
+    if (names.length > 1)
+        throw new models_1.ToolingError('INVALID_REQUEST', `Multiple workspace folders match ${uid}. Resolve the duplicate folders first.`);
+    return path.join(parent, names[0] || `${(0, repositories_1.safeSlug)(name)}-${uid}`);
+}
+/** Stable, independent branch checkouts. No reset, stash, force checkout, deletion or automatic pull. */
+async function setupOrganizationProject(input, options) {
+    const { session, signal, state } = options;
+    const backend = (0, session_1.requireBackend)(input.backend), environmentUid = (0, organizationProjects_1.projectUid)(input.environmentUid), uid = (0, organizationProjects_1.projectUid)(input.projectUid);
+    const env = (0, projects_1.projectEnvironment)({ backend }, options.env);
+    // Apply the same environment to nested Git helpers, including context and .env setup.
+    for (const key of Object.keys(env))
+        if (key.startsWith('GIT_') && key !== 'GIT_SSH_COMMAND')
+            delete env[key];
+    const host = { ...options.host, runProcess: spec => options.host.runProcess({ ...spec, env: spec.env ?? env }) };
+    if (typeof input.baseDir !== 'string' || !path.isAbsolute(input.baseDir) || /[\r\n\0]/.test(input.baseDir))
+        throw new models_1.ToolingError('INVALID_REQUEST', 'Choose an absolute repositories base folder in General.');
+    // Resolve the base once (macOS /tmp and home aliases are legitimate). Children must be ordinary directories.
+    let base = path.resolve(input.baseDir);
+    if (await exists(base))
+        base = await fs.realpath(base);
+    const client = new organizationProjects_1.OrganizationProjectClient(session, backend, signal);
+    const { project, branches } = await client.getProject(environmentUid, uid);
+    const displayName = workspaceName(project.name);
+    if (!branches.length)
+        throw new models_1.ToolingError('INVALID_REQUEST', 'This project has no accessible branches to set up.');
+    if (branches.length !== project.code_repository_branch_uids.length)
+        throw new models_1.ToolingError('API_ERROR', 'Project membership changed. Refresh it before setting up locally.');
+    const infos = [];
+    for (const branch of branches) {
+        signal?.throwIfAborted();
+        const info = await (0, repositories_1.repositorySetupInfo)(session, backend, branch.code_repository_uid, branch.repository_branch);
+        if (info.branch.uid !== branch.uid)
+            throw new models_1.ToolingError('API_ERROR', 'The selected project branch identity changed.');
+        infos.push(info);
+    }
+    const org = infos[0].orgSlug;
+    if (infos.some(info => info.orgSlug !== org))
+        throw new models_1.ToolingError('API_ERROR', 'The project repositories belong to different organizations.');
+    // The UID identifies the storage container, never the folder opened/displayed by Claude.
+    // Repositories are siblings of the named workspace: /add-dir must register each one,
+    // instead of treating nested checkouts as already covered by the working directory.
+    const container = await namedDirectory(path.join(base, org, 'organization-projects', (0, node_crypto_1.createHash)('sha256').update(backend).digest('hex').slice(0, 16)), project.name, uid);
+    const root = path.join(container, displayName);
+    const manifestPath = path.join(container, '.mainsequence-project.json');
+    await ordinaryDirectory(container);
+    let prior;
+    if (await exists(manifestPath)) {
+        prior = await readManifest(manifestPath);
+        if (![1, 2].includes(prior.schemaVersion) || prior.backend !== backend || prior.projectUid !== uid || prior.environmentUid !== environmentUid)
+            throw new models_1.ToolingError('INVALID_REQUEST', 'This workspace belongs to another project or backend.');
+    }
+    else if (await exists(container) && (await fs.readdir(container)).length)
+        throw new models_1.ToolingError('INVALID_REQUEST', 'The workspace folder already contains unmanaged files. Choose another base folder.');
+    await ordinaryDirectory(root);
+    if (await exists(root) && (await fs.readdir(root)).length && prior?.root !== root)
+        throw new models_1.ToolingError('INVALID_REQUEST', 'The named workspace folder already contains files. Resolve the folder collision before retrying.');
+    const run = async (cwd, args, mutation = false) => {
+        signal?.throwIfAborted();
+        if (mutation)
+            state.mutationStarted = true;
+        const result = await host.runProcess({ executable: 'git', args, cwd, env, signal, timeoutMs: 120_000 });
+        if (result.cancelled)
+            throw new models_1.ToolingError('CANCELLED', 'Project setup was cancelled. Completed checkouts are retained.');
+        if (result.exitCode !== 0)
+            throw new models_1.ToolingError('PROCESS_FAILED', `Git could not ${args[0]} in ${cwd}. Existing files were preserved; inspect the checkout before retrying.`);
+        return result.stdout.trim();
+    };
+    const repositories = [];
+    for (const info of infos) {
+        const branch = info.branch;
+        let sourcePath = (0, repositories_1.canonicalRepositoryDir)(base, org, info.repository.uid, info.repository.code_repository_name);
+        const sourceParent = path.dirname(sourcePath);
+        await ordinaryDirectory(sourceParent);
+        if (!await exists(sourcePath) && await exists(sourceParent)) {
+            const matches = (await fs.readdir(sourceParent)).filter(name => name.endsWith(`-${info.repository.uid}`));
+            if (matches.length > 1)
+                throw new models_1.ToolingError('INVALID_REQUEST', 'Multiple local repositories match this repository UID. Resolve the duplicate folders first.');
+            if (matches.length === 1)
+                sourcePath = path.join(sourceParent, matches[0]);
+        }
+        const repositoryFolder = await namedDirectory(path.join(container, 'repositories'), info.repository.code_repository_name, info.repository.uid);
+        const target = await namedDirectory(repositoryFolder, branch.repository_branch, branch.uid);
+        for (const candidate of [sourcePath, target]) {
+            await ordinaryDirectory(candidate);
+            if (!await exists(candidate))
+                continue;
+            const gitDir = path.join(candidate, '.git');
+            if (!await exists(gitDir) || (await fs.lstat(gitDir)).isSymbolicLink() || !(await fs.lstat(gitDir)).isDirectory())
+                throw new models_1.ToolingError('INVALID_REQUEST', 'Project setup requires standalone repository checkouts.');
+            const origin = await run(candidate, ['remote', 'get-url', 'origin']);
+            if ((0, repositoryIdentity_1.repositorySshKeyIdentity)(origin).identity !== (0, repositoryIdentity_1.repositorySshKeyIdentity)(info.binding.git_ssh_url || '').identity)
+                throw new models_1.ToolingError('INVALID_GIT_CONTEXT', `The checkout origin does not match ${info.repository.code_repository_name}.`);
+            if (candidate === target && await run(candidate, ['symbolic-ref', '--short', 'HEAD']) !== branch.repository_branch && await run(candidate, ['status', '--porcelain']))
+                throw new models_1.ToolingError('INVALID_REQUEST', `Commit or stash changes in ${candidate} before switching its branch.`);
+        }
+        repositories.push({ repositoryUid: info.repository.uid, branchUid: branch.uid, name: info.repository.code_repository_name, branch: branch.repository_branch, path: target, sourcePath });
+    }
+    // Phase 1: ensure the ordinary repository exists, without switching existing source checkouts.
+    for (const row of repositories) {
+        if (!await exists(row.sourcePath)) {
+            host.progress?.(`Preparing repository ${row.name}.`);
+            await (0, projects_1.setupRepository)(host, session, { backend, repositoryUid: row.repositoryUid, branch: row.branch, baseDir: base }, { env, signal, state });
+        }
+    }
+    signal?.throwIfAborted();
+    state.mutationStarted = true;
+    await ordinaryDirectory(container, true);
+    return (0, projects_1.withProjectLock)(container, async () => {
+        if (prior?.schemaVersion === 2 && prior.root !== root) {
+            const previousRoot = path.join(container, workspaceName(prior.name));
+            if (prior.root !== previousRoot)
+                throw new models_1.ToolingError('INVALID_REQUEST', 'The previous workspace location is invalid.');
+            await ordinaryDirectory(previousRoot);
+            if (await exists(previousRoot)) {
+                if (await exists(root))
+                    throw new models_1.ToolingError('INVALID_REQUEST', 'The renamed workspace folder already exists.');
+                await fs.rename(previousRoot, root);
+            }
+        }
+        await ordinaryDirectory(root, true);
+        const manifest = { schemaVersion: 2, backend, environmentUid, projectUid: uid, name: project.name, root, repositories, status: 'preparing' };
+        // Phase 2: persist the stable Claude workspace before preparing its individual checkouts.
+        await atomicJson(manifestPath, manifest);
+        await atomicJson(path.join(root, '.mainsequence-project.json'), manifest);
+        // Phase 3: each membership gets its own attached branch, including several branches of one repository.
+        for (const row of repositories) {
+            signal?.throwIfAborted();
+            host.progress?.(`Preparing ${row.name} on ${row.branch}.`);
+            if (!await exists(row.path)) {
+                await (0, projects_1.setupRepository)(host, session, { backend, repositoryUid: row.repositoryUid, branch: row.branch, baseDir: container }, { env, signal, state, destination: row.path, reference: row.sourcePath });
+            }
+            else {
+                const context = await (0, repositories_1.projectContext)(host, row.path, backend, undefined, env, signal);
+                await (0, projects_1.withProjectLock)(context.gitCommonDir, async () => {
+                    if (context.branch === row.branch)
+                        return;
+                    if (await run(row.path, ['status', '--porcelain']))
+                        throw new models_1.ToolingError('INVALID_REQUEST', `Commit or stash changes in ${row.path} before switching its branch.`);
+                    await run(row.path, ['check-ref-format', '--branch', row.branch]);
+                    await run(row.path, ['fetch', '--', 'origin', `refs/heads/${row.branch}:refs/remotes/origin/${row.branch}`], true);
+                    const local = await host.runProcess({ executable: 'git', args: ['show-ref', '--verify', '--quiet', `refs/heads/${row.branch}`], cwd: row.path, env, signal });
+                    if (local.cancelled)
+                        throw new models_1.ToolingError('CANCELLED', 'Project setup was cancelled.');
+                    if (![0, 1].includes(local.exitCode ?? -1))
+                        throw new models_1.ToolingError('INVALID_GIT_CONTEXT', 'Could not inspect the local branch.');
+                    await run(row.path, local.exitCode === 0 ? ['switch', '--no-guess', '--', row.branch] : ['switch', '--create', row.branch, '--track', `origin/${row.branch}`], true);
+                });
+            }
+            if (await run(row.path, ['symbolic-ref', '--short', 'HEAD']) !== row.branch)
+                throw new models_1.ToolingError('INVALID_GIT_CONTEXT', 'The checkout did not select the project branch.');
+        }
+        const instructions = path.join(root, 'CLAUDE.md');
+        if (!await exists(instructions)) {
+            const legacyInstructions = path.join(container, 'CLAUDE.md');
+            const content = prior?.schemaVersion === 1 && await exists(legacyInstructions)
+                ? await fs.readFile(legacyInstructions, 'utf8')
+                : '# MainSequence workspace\n\nThe project repositories and their assigned branches are listed in `.mainsequence-project.json`.\nThe MainSequence plugin adds each repository to this Claude session with `/add-dir`.\nWork inside the appropriate repository directory; each checkout has its own Git history and instructions.\n';
+            await fs.writeFile(instructions, content, { flag: 'wx' });
+        }
+        await atomicJson(manifestPath, { ...manifest, status: 'ready' });
+        await atomicJson(path.join(root, '.mainsequence-project.json'), { ...manifest, status: 'ready' });
+        const claudeUrl = new URL('claude://code/new');
+        claudeUrl.searchParams.set('folder', root);
+        return { root, name: project.name, projectUid: uid, environmentUid, repositories, claudeUrl: claudeUrl.href };
+    });
+}

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

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrganizationProjectClient = void 0;
+exports.projectUid = projectUid;
+const models_1 = require("./models.js");
+const session_1 = require("./session.js");
+const repositoryModels_1 = require("./repositoryModels.js");
+const repositoryClient_1 = require("./repositoryClient.js");
+const environments_1 = require("./environments.js");
+function projectUid(value, label = 'UID') {
+    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', `${label} must be a UUID.`);
+    return value.toLowerCase();
+}
+function object(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new models_1.ToolingError('API_ERROR', 'The project service returned an invalid object.');
+    return value;
+}
+function line(value, label) {
+    if (typeof value !== 'string' || !value.trim() || /[\r\n\0]/.test(value))
+        throw new models_1.ToolingError('API_ERROR', `Invalid ${label}.`);
+    return value;
+}
+function project(value, environmentUid) {
+    const row = object(value);
+    if (projectUid(row.organization_environment_uid) !== environmentUid || !Array.isArray(row.code_repository_branch_uids) || typeof row.description !== 'string')
+        throw new models_1.ToolingError('API_ERROR', 'The project response does not match the selected environment.');
+    return { uid: projectUid(row.uid), organization_environment_uid: environmentUid, name: line(row.name, 'project name'), description: row.description,
+        code_repository_branch_uids: [...new Set(row.code_repository_branch_uids.map((uid) => projectUid(uid, 'Branch UID')))] };
+}
+function pageValues(value) {
+    const payload = object(value);
+    if (!Array.isArray(payload.results) || !Number.isSafeInteger(payload.count) || payload.count < 0)
+        throw new models_1.ToolingError('API_ERROR', 'The project service returned an invalid page.');
+    return { results: payload.results, count: payload.count };
+}
+function webUrl(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new models_1.ToolingError('INVALID_REQUEST', 'Enter an absolute Command Center or repository web URL.');
+    }
+    if (!['https:', 'http:'].includes(url.protocol) || url.username || url.password)
+        throw new models_1.ToolingError('INVALID_REQUEST', 'Links must use HTTP(S) without embedded credentials.');
+    return url;
+}
+/** Human desktop clients: exact environment scope, branch membership and permission-filtered data. */
+class OrganizationProjectClient {
+    session;
+    signal;
+    backend;
+    constructor(session, backend, signal) {
+        this.session = session;
+        this.signal = signal;
+        this.backend = (0, session_1.requireBackend)(backend);
+    }
+    async get(apiPath) { this.signal?.throwIfAborted(); return this.session.request(this.backend, 'GET', apiPath); }
+    async environments() {
+        return (await (0, environments_1.listEnvironments)(this.session, this.backend, this.signal)).map(({ uid, name }) => ({ uid, name }));
+    }
+    async list(environment, options = {}) {
+        const environmentUid = projectUid(environment, 'Environment UID'), limit = options.limit ?? 25, offset = options.offset ?? 0;
+        if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100 || !Number.isSafeInteger(offset) || offset < 0 || (options.search !== undefined && typeof options.search !== 'string'))
+            throw new models_1.ToolingError('INVALID_REQUEST', 'Invalid project pagination or search.');
+        const query = new URLSearchParams({ organization_environment_uid: environmentUid, limit: String(limit), offset: String(offset), ordering: 'name' });
+        if (options.search?.trim())
+            query.set('search', options.search.trim());
+        const payload = pageValues(await this.get(`/api/v1/organization-projects/?${query}`));
+        return { results: payload.results.map(row => project(row, environmentUid)), count: payload.count, limit, offset };
+    }
+    async detail(environment, uid) {
+        const environmentUid = projectUid(environment, 'Environment UID'), selectedUid = projectUid(uid, 'Project UID');
+        const selected = project(await this.get(`/api/v1/organization-projects/${selectedUid}/`), environmentUid);
+        if (selected.uid !== selectedUid)
+            throw new models_1.ToolingError('API_ERROR', 'The backend returned another project.');
+        return selected;
+    }
+    async branches(selected) {
+        const payload = await this.get(`/api/v1/organization-projects/${projectUid(selected.uid)}/code-repository-branches/`);
+        if (!Array.isArray(payload))
+            throw new models_1.ToolingError('API_ERROR', 'The project branch response must be an array.');
+        const seen = new Set();
+        return payload.map(value => {
+            const branch = (0, repositoryModels_1.codeRepositoryBranchFromResponse)(value, 'Project branch');
+            const uid = projectUid(branch.uid), environment = projectUid(value.organization_environment_uid);
+            if (seen.has(uid) || environment !== selected.organization_environment_uid || !selected.code_repository_branch_uids.includes(uid))
+                throw new models_1.ToolingError('API_ERROR', 'Project membership changed or contains an invalid branch. Refresh the project.');
+            seen.add(uid);
+            return { ...branch, uid, code_repository_uid: projectUid(branch.code_repository_uid), organization_environment_uid: environment, code_repository_type: line(value.code_repository_type, 'repository type') };
+        });
+    }
+    async getProject(environment, uid) { const selected = await this.detail(environment, uid); return { project: selected, branches: await this.branches(selected) }; }
+    async link(input) {
+        const selected = await this.detail(input.environmentUid, input.projectUid);
+        if (!['project', 'repository', 'branch'].includes(input.target))
+            throw new models_1.ToolingError('INVALID_REQUEST', 'Choose a project, repository or branch link.');
+        const branch = input.target === 'project' ? undefined : (await this.branches(selected)).find(row => row.uid === projectUid(input.branchUid, 'Branch UID'));
+        if (input.target !== 'project' && !branch)
+            throw new models_1.ToolingError('INVALID_REQUEST', 'The selected branch is no longer a member of this project.');
+        if (input.commandCenterUrl?.trim()) {
+            const url = webUrl(input.commandCenterUrl.trim());
+            url.pathname = `/app/main-sequence-foundry/${branch ? 'code-repositories' : 'projects'}`;
+            url.search = '';
+            url.hash = '';
+            if (branch) {
+                url.searchParams.set('msCodeRepositoryUid', branch.code_repository_uid);
+                if (input.target === 'branch')
+                    url.searchParams.set('msCodeRepositoryBranchUid', branch.uid);
+                url.searchParams.set('msTab', 'code');
+            }
+            else
+                url.searchParams.set('msProjectUid', selected.uid);
+            return url.href;
+        }
+        if (!branch?.github_repository_binding_uid)
+            throw new models_1.ToolingError('INVALID_REQUEST', 'Set the Command Center URL in General to open this resource.');
+        const binding = await new repositoryClient_1.RepositoryClient(this.session, this.backend).getGitHubRepositoryBinding(branch.github_repository_binding_uid);
+        if (binding.uid !== branch.github_repository_binding_uid || binding.code_repository_uid !== branch.code_repository_uid)
+            throw new models_1.ToolingError('API_ERROR', 'The repository link does not match the selected branch.');
+        if (!binding.git_repo_url)
+            throw new models_1.ToolingError('INVALID_REQUEST', 'No repository web link is available. Set the Command Center URL in General.');
+        const url = webUrl(binding.git_repo_url);
+        url.search = '';
+        url.hash = '';
+        url.pathname = url.pathname.replace(/\.git\/?$/, '').replace(/\/$/, '');
+        if (input.target === 'branch')
+            url.pathname += '/tree/' + encodeURIComponent(branch.repository_branch);
+        return url.href;
+    }
+}
+exports.OrganizationProjectClient = OrganizationProjectClient;

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runProcess = runProcess;
+exports.createNodeHost = createNodeHost;
+const child_process_1 = require("child_process");
+/** Never prints arguments, environment, or child output. Consumers receive private captured data. */
+function runProcess(spec) {
+    if (spec.signal?.aborted)
+        return Promise.resolve({ exitCode: null, stdout: '', stderr: '', cancelled: true });
+    return new Promise(resolve => {
+        let stdout = '', stderr = '', cancelled = false, timedOut = false;
+        let killTimer;
+        let settled = false;
+        const child = (0, child_process_1.spawn)(spec.executable, spec.args, {
+            cwd: spec.cwd, env: spec.env ?? process.env,
+            shell: false, windowsHide: true, detached: process.platform !== 'win32', stdio: ['ignore', 'pipe', 'pipe']
+        });
+        const kill = (signal) => {
+            try {
+                if (process.platform !== 'win32' && child.pid)
+                    process.kill(-child.pid, signal);
+                else
+                    child.kill(signal);
+            }
+            catch { /* exited */ }
+        };
+        const stop = () => {
+            kill('SIGTERM');
+            killTimer ??= setTimeout(() => kill('SIGKILL'), 1500);
+        };
+        const abort = () => { cancelled = true; stop(); };
+        spec.signal?.addEventListener('abort', abort, { once: true });
+        const timer = setTimeout(() => { timedOut = true; stop(); }, spec.timeoutMs ?? 600_000);
+        const finish = (exitCode, unavailable = false) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (killTimer)
+                clearTimeout(killTimer);
+            spec.signal?.removeEventListener('abort', abort);
+            resolve({ exitCode, stdout, stderr, cancelled, timedOut, unavailable });
+        };
+        // Bounded private buffers; stdout never goes to hooks, progress, or ordinary logs.
+        child.stdout?.on('data', chunk => { stdout = (stdout + chunk.toString()).slice(-2_000_000); });
+        child.stderr?.on('data', chunk => { stderr = (stderr + chunk.toString()).slice(-2_000_000); });
+        child.once('error', () => finish(null, true));
+        child.once('close', code => finish(code));
+    });
+}
+function createNodeHost(progress) {
+    return {
+        runProcess, progress,
+        async openBrowser(url) {
+            const program = process.platform === 'darwin' ? '/usr/bin/open' : process.platform === 'win32' ? 'rundll32.exe' : 'xdg-open';
+            const args = process.platform === 'win32' ? ['url.dll,FileProtocolHandler', url] : [url];
+            const result = await runProcess({ executable: program, args, cwd: process.cwd(), timeoutMs: 15_000 });
+            return result.exitCode === 0;
+        }
+    };
+}