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

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

@@ -0,0 +1,215 @@
+"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.readProjectEnv = readProjectEnv;
+exports.resolveBackend = resolveBackend;
+exports.readWorkspacePreferences = readWorkspacePreferences;
+exports.git = git;
+exports.projectContext = projectContext;
+exports.detectProjectType = detectProjectType;
+exports.listRepositories = listRepositories;
+exports.resolveRepository = resolveRepository;
+exports.repositorySetupInfo = repositorySetupInfo;
+exports.safeSlug = safeSlug;
+exports.canonicalRepositoryDir = canonicalRepositoryDir;
+// Git identity and canonical layout extracted from the VS Code extension.
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const models_1 = require("./models.js");
+const session_1 = require("./session.js");
+const repositoryIdentity_1 = require("./repositoryIdentity.js");
+const repositoryClient_1 = require("./repositoryClient.js");
+const repositoryModels_1 = require("./repositoryModels.js");
+async function readProjectEnv(root) {
+    let text;
+    try {
+        text = await fs.readFile(path.join(root, '.env'), 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return {};
+        throw new models_1.ToolingError('INVALID_REQUEST', 'The project .env could not be read.');
+    }
+    const values = {};
+    for (const line of text.split(/\r?\n/)) {
+        const match = line.match(/^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*?)\s*$/);
+        if (!match)
+            continue;
+        let value = match[2];
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'")))
+            value = value.slice(1, -1);
+        else
+            value = value.replace(/\s+#.*$/, '').trim();
+        values[match[1]] = value;
+    }
+    return values;
+}
+async function resolveBackend(explicit, root, env = process.env) {
+    if (explicit)
+        return (0, session_1.requireBackend)(explicit);
+    if (env.MAINSEQUENCE_ENDPOINT)
+        return (0, session_1.requireBackend)(env.MAINSEQUENCE_ENDPOINT);
+    if (root) {
+        const projectEnv = await readProjectEnv(root);
+        if (projectEnv.MAINSEQUENCE_ENDPOINT)
+            return (0, session_1.requireBackend)(projectEnv.MAINSEQUENCE_ENDPOINT);
+    }
+    return (await readWorkspacePreferences({ env })).backend;
+}
+/** Resolve non-secret workspace settings without requiring a session or writing configuration. */
+async function readWorkspacePreferences(options = {}) {
+    const env = options.env ?? process.env, home = options.homeDir ?? os.homedir();
+    const directory = process.platform === 'darwin' ? path.join(home, 'Library', 'Application Support', 'MainSequenceCLI')
+        : process.platform === 'win32' ? path.join(env.APPDATA || home, 'MainSequenceCLI') : path.join(home, '.config', 'mainsequence');
+    const config = await fs.readFile(options.configPath ?? path.join(directory, 'config.json'), 'utf8')
+        .then(text => JSON.parse(text)).catch(() => ({}));
+    const folder = config?.mainsequence_path;
+    return { backend: (0, session_1.requireBackend)(env.MAINSEQUENCE_ENDPOINT || (typeof config?.backend_url === 'string' && config.backend_url.trim()) || 'https://api.main-sequence.app'),
+        baseDir: typeof folder === 'string' && path.isAbsolute(folder) && !/[\0\r\n]/.test(folder) ? folder : path.join(home, 'mainsequence') };
+}
+async function git(host, cwd, args, signal) {
+    const result = await host.runProcess({ executable: 'git', args, cwd, signal, timeoutMs: 15_000 });
+    if (result.cancelled)
+        throw new models_1.ToolingError('CANCELLED', 'The action was cancelled.');
+    if (result.exitCode !== 0)
+        throw new models_1.ToolingError('INVALID_GIT_CONTEXT', 'Git could not resolve the required worktree, attached branch, commit, or origin.');
+    return result.stdout.trim();
+}
+async function projectContext(host, root, backend, projectType, env, signal) {
+    let requested;
+    try {
+        requested = await fs.realpath(path.resolve(root));
+    }
+    catch {
+        throw new models_1.ToolingError('PROJECT_NOT_FOUND', 'The project directory does not exist.');
+    }
+    const resolved = await fs.realpath(await git(host, requested, ['rev-parse', '--show-toplevel'], signal));
+    const relative = path.relative(resolved, requested);
+    if (relative === '..' || relative.startsWith('..' + path.sep) || path.isAbsolute(relative))
+        throw new models_1.ToolingError('INVALID_GIT_CONTEXT', 'Git resolved a worktree outside the selected project directory. Check inherited Git environment overrides.');
+    const ref = await git(host, resolved, ['symbolic-ref', '--quiet', 'HEAD'], signal);
+    if (!ref.startsWith('refs/heads/'))
+        throw new models_1.ToolingError('INVALID_GIT_CONTEXT', 'An attached Git branch is required.');
+    const branch = ref.slice('refs/heads/'.length);
+    const commit = (await git(host, resolved, ['rev-parse', '--verify', 'HEAD^{commit}'], signal)).toLowerCase();
+    if (!/^[0-9a-f]{40}$/.test(commit))
+        throw new models_1.ToolingError('INVALID_GIT_CONTEXT', 'A full Git commit SHA is required.');
+    let remote;
+    try {
+        remote = await git(host, resolved, ['config', '--get', `branch.${branch}.remote`], signal);
+    }
+    catch {
+        remote = '';
+    }
+    if (!remote || remote === '.') {
+        const remotes = (await git(host, resolved, ['remote'], signal)).split(/\r?\n/).filter(Boolean);
+        remote = remotes.includes('origin') ? 'origin' : remotes.length === 1 ? remotes[0] : '';
+    }
+    if (!remote)
+        throw new models_1.ToolingError('INVALID_GIT_CONTEXT', 'The project Git remote is ambiguous.');
+    const origin = await git(host, resolved, ['remote', 'get-url', remote], signal);
+    let identity;
+    try {
+        identity = (0, repositoryIdentity_1.repositorySshKeyIdentity)(origin).identity;
+    }
+    catch {
+        throw new models_1.ToolingError('INVALID_GIT_CONTEXT', 'The Git origin is not a supported repository URL.');
+    }
+    const common = await git(host, resolved, ['rev-parse', '--git-common-dir'], signal);
+    const backendUrl = await resolveBackend(backend, resolved, env);
+    const type = projectType ?? await detectProjectType(resolved);
+    return { root: resolved, projectType: type, backend: backendUrl, origin: safeOrigin(origin), repositoryIdentity: identity, branch, ref, commit, gitCommonDir: path.resolve(resolved, common) };
+}
+function safeOrigin(origin) {
+    if (!origin.includes('://'))
+        return origin;
+    const parsed = new URL(origin);
+    parsed.username = '';
+    parsed.password = '';
+    parsed.search = '';
+    parsed.hash = '';
+    return parsed.toString();
+}
+async function detectProjectType(root) {
+    const python = await fs.stat(path.join(root, 'pyproject.toml')).then(s => s.isFile()).catch(() => false);
+    const node = await fs.readFile(path.join(root, 'package.json'), 'utf8').then(text => {
+        const pkg = JSON.parse(text);
+        return Boolean(pkg.dependencies?.['@dev-mainsequence/command-center-sdk'] || pkg.devDependencies?.['@dev-mainsequence/command-center-sdk']);
+    }).catch(() => false);
+    return python === node ? undefined : python ? 'python' : 'vite_react';
+}
+async function listRepositories(session, backend) {
+    const payload = await session.request(backend, 'GET', '/api/v1/code-repositories/');
+    const values = Array.isArray(payload) ? payload : payload?.results;
+    if (!Array.isArray(values))
+        throw new models_1.ToolingError('API_ERROR', 'The backend repository list has an invalid shape.');
+    return values.map((value, index) => (0, repositoryModels_1.codeRepositoryFromResponse)(value, `CodeRepository ${index}`));
+}
+async function resolveRepository(session, context) {
+    return new repositoryClient_1.RepositoryClient(session, context.backend).resolveCodeRepositoryGitContext({ repositoryIdentity: context.repositoryIdentity, repositoryBranch: context.branch, commitSha: context.commit });
+}
+async function repositorySetupInfo(session, backend, uid, branchName) {
+    const repository = (0, repositoryModels_1.codeRepositoryFromResponse)(await session.request(backend, 'GET', `/api/v1/code-repositories/${encodeURIComponent(uid)}/`), 'CodeRepository');
+    if (repository.uid !== uid)
+        throw new models_1.ToolingError('API_ERROR', 'The backend returned another CodeRepository.');
+    const summary = repository.branches.find(branch => branch.repository_branch === branchName);
+    if (!summary)
+        throw new models_1.ToolingError('INVALID_REQUEST', 'The requested branch is not registered for this CodeRepository.');
+    const branch = (0, repositoryModels_1.codeRepositoryBranchFromResponse)(await session.request(backend, 'GET', `/api/v1/code-repository-branches/${encodeURIComponent(summary.uid)}/`), 'CodeRepositoryBranch');
+    if (branch.uid !== summary.uid || branch.code_repository_uid !== uid || branch.repository_branch !== branchName)
+        throw new models_1.ToolingError('API_ERROR', 'The backend returned another repository branch.');
+    if (!branch.is_initialized)
+        throw new models_1.ToolingError('INVALID_REQUEST', 'This CodeRepositoryBranch has not finished initializing.');
+    const bindingUid = branch.github_repository_binding_uid || repository.github_repository_binding_uid;
+    if (!bindingUid)
+        throw new models_1.ToolingError('API_ERROR', 'This repository has no GitHub binding.');
+    const binding = (0, repositoryModels_1.gitHubRepositoryBindingFromResponse)(await session.request(backend, 'GET', `/api/v1/github-repository-bindings/${encodeURIComponent(bindingUid)}/`), 'GitHub binding');
+    if (binding.code_repository_uid !== uid || binding.uid !== bindingUid)
+        throw new models_1.ToolingError('API_ERROR', 'The GitHub binding belongs to another repository.');
+    const profile = await session.request(backend, 'GET', '/api/v1/users/me/');
+    const user = profile?.user || profile;
+    const organization = user?.organization || profile?.organization || {};
+    const orgName = typeof organization === 'string' ? organization : organization.name || organization.slug || organization.uid || 'default';
+    return { repository, branch, binding, orgSlug: safeSlug(orgName) };
+}
+function safeSlug(value) {
+    return String(value || 'code-repository').toLowerCase().replace(/[^a-z0-9-_]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 64) || 'code-repository';
+}
+function canonicalRepositoryDir(base, org, uid, name) {
+    if (!/^[A-Za-z0-9._-]+$/.test(uid) || uid === '.' || uid === '..')
+        throw new models_1.ToolingError('INVALID_REQUEST', 'The CodeRepository UID must be a filesystem-safe segment.');
+    return path.join(path.resolve(base), safeSlug(org), 'projects', `${safeSlug(name)}-${uid}`);
+}

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

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepositoryClient = void 0;
+const models_1 = require("./models.js");
+const repositoryModels_1 = require("./repositoryModels.js");
+const AUTH_PATHS = { userDetails: '/api/v1/users/me/' };
+const ApiError = Error;
+function requiredObject(value, label) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new models_1.ToolingError('API_ERROR', `${label} must be an object.`);
+    return value;
+}
+function requiredSingleLine(value, label) {
+    if (typeof value !== 'string' || !value.trim() || /[\r\n\0]/.test(value))
+        throw new models_1.ToolingError('INVALID_REQUEST', `${label} is required.`);
+    return value.trim();
+}
+class RepositoryClient {
+    session;
+    backend;
+    constructor(session, backend) {
+        this.session = session;
+        this.backend = backend;
+    }
+    async authed(method, apiPath, body) {
+        const retrySafe = method === 'GET' || apiPath === '/api/v1/code-repository-branches/resolve-git-context/';
+        return { data: await this.session.request(this.backend, method, apiPath, body, retrySafe) };
+    }
+    async getCurrentUserProfile() {
+        const details = await this.authed('GET', AUTH_PATHS.userDetails);
+        const detailsData = details.data || {};
+        const detailsUser = detailsData.user || detailsData;
+        const userUid = typeof detailsUser?.uid === 'string' ? detailsUser.uid.trim() : '';
+        const detailsOrg = detailsUser?.organization || detailsData.organization || {};
+        const org = detailsUser?.organization || detailsOrg || {};
+        const orgName = typeof org === 'string'
+            ? org
+            : (org?.name || org?.slug || detailsUser?.organization_name || detailsData.organization_name || '');
+        const organizationUid = typeof org === 'object' && org
+            ? (org?.uid || detailsOrg?.uid || '')
+            : '';
+        return {
+            username: detailsUser?.username || '',
+            organization: orgName,
+            uid: userUid,
+            organizationUid
+        };
+    }
+    async getCodeRepositories() {
+        const r = await this.authed('GET', '/api/v1/code-repositories/');
+        const data = r.data || {};
+        const results = Array.isArray(data) ? data : data.results || [];
+        if (!Array.isArray(results))
+            throw new ApiError('CodeRepository list returned an unexpected payload.');
+        return results.map((value, index) => (0, repositoryModels_1.codeRepositoryFromResponse)(value, `CodeRepository list item ${index}`));
+    }
+    async getCodeRepository(codeRepositoryUid) {
+        const uid = requiredSingleLine(codeRepositoryUid, 'CodeRepository UID');
+        const r = await this.authed('GET', `/api/v1/code-repositories/${encodeURIComponent(uid)}/`);
+        return (0, repositoryModels_1.codeRepositoryFromResponse)(r.data, 'CodeRepository response');
+    }
+    async getCodeRepositoryBranch(codeRepositoryBranchUid) {
+        const uid = requiredSingleLine(codeRepositoryBranchUid, 'CodeRepositoryBranch UID');
+        const r = await this.authed('GET', `/api/v1/code-repository-branches/${encodeURIComponent(uid)}/`);
+        return (0, repositoryModels_1.codeRepositoryBranchFromResponse)(r.data, 'CodeRepositoryBranch response');
+    }
+    async getGitHubRepositoryBinding(repositoryUid) {
+        const uid = requiredSingleLine(repositoryUid, 'GitHubRepositoryBinding UID');
+        const r = await this.authed('GET', `/api/v1/github-repository-bindings/${encodeURIComponent(uid)}/`);
+        return (0, repositoryModels_1.gitHubRepositoryBindingFromResponse)(r.data, 'GitHubRepositoryBinding response');
+    }
+    async addCodeRepositoryDeployKey(codeRepositoryUid, keyTitle, publicKey) {
+        const uid = requiredSingleLine(codeRepositoryUid, 'CodeRepository UID');
+        const title = requiredSingleLine(keyTitle, 'Deploy-key title');
+        const key = requiredSingleLine(publicKey, 'Deploy-key public key');
+        await this.authed('POST', `/api/v1/code-repositories/${encodeURIComponent(uid)}/add-deploy-key/`, {
+            key_title: title, public_key: key
+        });
+    }
+    async resolveCodeRepositoryGitContext(input) {
+        const repositoryIdentity = requiredSingleLine(input.repositoryIdentity, 'Git repository identity');
+        const repositoryBranch = requiredSingleLine(input.repositoryBranch, 'Git branch');
+        const commitSha = requiredSingleLine(input.commitSha, 'Git commit').toLowerCase();
+        if (!/^[0-9a-f]{40}$/.test(commitSha))
+            throw new ApiError('Git commit must be a canonical full SHA.');
+        const r = await this.authed('POST', '/api/v1/code-repository-branches/resolve-git-context/', {
+            repository_identity: repositoryIdentity,
+            repository_branch: repositoryBranch,
+            commit_sha: commitSha
+        });
+        const payload = requiredObject(r.data, 'Git-context resolution');
+        const branch = (0, repositoryModels_1.codeRepositoryBranchFromResponse)(payload.code_repository_branch, 'Resolved CodeRepositoryBranch');
+        if (payload.canonical_repository_identity !== repositoryIdentity) {
+            throw new ApiError('Git-context resolution returned another canonical repository identity.');
+        }
+        if (payload.repository_branch !== repositoryBranch || branch.repository_branch !== repositoryBranch) {
+            throw new ApiError('Git-context resolution returned another repository branch.');
+        }
+        if (payload.repository_ref !== `refs/heads/${repositoryBranch}`) {
+            throw new ApiError('Git-context resolution returned another attached Git ref.');
+        }
+        if (String(payload.commit_sha || '').toLowerCase() !== commitSha) {
+            throw new ApiError('Git-context resolution returned another Git commit.');
+        }
+        return { ...payload, code_repository_branch: branch };
+    }
+}
+exports.RepositoryClient = RepositoryClient;

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

@@ -0,0 +1,116 @@
+"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.repositorySshKeyIdentity = repositorySshKeyIdentity;
+exports.repositorySshKeyName = repositorySshKeyName;
+exports.repositorySshKeyPaths = repositorySshKeyPaths;
+const crypto = __importStar(require("crypto"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const SUPPORTED_GIT_ORIGIN_SCHEMES = new Set(['git', 'git+ssh', 'http', 'https', 'ssh']);
+const SSH_GIT_ORIGIN_SCHEMES = new Set(['git+ssh', 'ssh']);
+const DEFAULT_GIT_ORIGIN_PORTS = {
+    http: '80',
+    https: '443',
+    ssh: '22',
+    'git+ssh': '22'
+};
+const SCP_GIT_ORIGIN_PATTERN = /^(?:[^@/\s]+@)?(?<host>[^:/\s]+):(?<path>.+)$/;
+function repositorySshKeyIdentity(repoUrl) {
+    const candidate = String(repoUrl || '').trim().replace(/[?#].*$/, '');
+    if (!candidate)
+        throw new Error('Git origin must be non-empty.');
+    if (/[\r\n]/.test(candidate))
+        throw new Error('Git origin must contain one non-empty line.');
+    const schemeMatch = candidate.match(/^(?<scheme>[A-Za-z][A-Za-z0-9+.-]*):\/\//);
+    if (schemeMatch?.groups) {
+        const scheme = schemeMatch.groups.scheme.toLowerCase();
+        if (!SUPPORTED_GIT_ORIGIN_SCHEMES.has(scheme)) {
+            throw new Error(`Unsupported Git origin scheme: ${scheme}.`);
+        }
+        let parsed;
+        try {
+            parsed = new URL(candidate);
+        }
+        catch {
+            throw new Error(`Invalid Git origin: ${repoUrl}.`);
+        }
+        const host = parsed.hostname.toLowerCase().replace(/\.$/, '');
+        if (!host)
+            throw new Error('Git origin must include a hostname.');
+        const repositoryPath = cleanGitRepositoryPath(parsed.pathname);
+        const port = parsed.port;
+        const defaultPort = DEFAULT_GIT_ORIGIN_PORTS[scheme];
+        const hostIdentity = !port || port === defaultPort ? host : `${host}:${port}`;
+        return {
+            identity: `${hostIdentity}/${repositoryPath}`,
+            usesSsh: SSH_GIT_ORIGIN_SCHEMES.has(scheme)
+        };
+    }
+    const scpMatch = candidate.match(SCP_GIT_ORIGIN_PATTERN);
+    if (!scpMatch?.groups) {
+        throw new Error('Git origin must be an SSH, Git, HTTP, or HTTPS repository URL.');
+    }
+    const host = scpMatch.groups.host.toLowerCase().replace(/\.$/, '');
+    const repositoryPath = cleanGitRepositoryPath(scpMatch.groups.path);
+    return { identity: `${host}/${repositoryPath}`, usesSsh: true };
+}
+function repositorySshKeyName(repoUrl) {
+    const { identity } = repositorySshKeyIdentity(repoUrl);
+    const repositoryName = identity.split('/').pop() || '';
+    const slug = repositoryName
+        .replace(/[^A-Za-z0-9._-]+/g, '-')
+        .replace(/^[._-]+|[._-]+$/g, '')
+        .toLowerCase()
+        .slice(0, 48)
+        .replace(/[._-]+$/g, '') || 'repository';
+    const digest = crypto.createHash('sha256').update(identity, 'utf8').digest('hex').slice(0, 16);
+    return `mainsequence-${slug}-${digest}`;
+}
+function repositorySshKeyPaths(repoUrl) {
+    const keyPath = path.join(os.homedir(), '.ssh', repositorySshKeyName(repoUrl));
+    return { keyPath, pubPath: `${keyPath}.pub` };
+}
+function cleanGitRepositoryPath(value) {
+    if (value.includes('\\'))
+        throw new Error('Git origin repository paths must use forward slashes.');
+    let repositoryPath = value.replace(/\/{2,}/g, '/').replace(/^\/+|\/+$/g, '');
+    if (repositoryPath.toLowerCase().endsWith('.git'))
+        repositoryPath = repositoryPath.slice(0, -4);
+    repositoryPath = repositoryPath.replace(/\/+$/g, '');
+    if (!repositoryPath)
+        throw new Error('Git origin must include a repository path.');
+    return repositoryPath;
+}

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codeRepositoryFromResponse = codeRepositoryFromResponse;
+exports.codeRepositoryBranchFromResponse = codeRepositoryBranchFromResponse;
+exports.gitHubRepositoryBindingFromResponse = gitHubRepositoryBindingFromResponse;
+const models_1 = require("./models.js");
+class ApiError extends models_1.ToolingError {
+    constructor(message) { super('API_ERROR', message); }
+}
+function requiredSingleLine(value, label) {
+    const normalized = typeof value === 'string' ? value.trim() : '';
+    if (!normalized || /[\r\n]/.test(normalized))
+        throw new ApiError(`${label} is required.`);
+    return normalized;
+}
+function requiredObject(value, label) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new ApiError(`${label} must be an object.`);
+    }
+    return value;
+}
+function optionalSingleLine(value, label) {
+    if (value == null)
+        return value;
+    return requiredSingleLine(value, label);
+}
+function codeRepositoryFromResponse(value, label) {
+    const payload = requiredObject(value, label);
+    if (!Array.isArray(payload.branches))
+        throw new ApiError(`${label}.branches must be an array.`);
+    return {
+        uid: requiredSingleLine(payload.uid, `${label} UID`),
+        code_repository_name: requiredSingleLine(payload.code_repository_name, `${label} name`),
+        code_repository_type: requiredSingleLine(payload.code_repository_type, `${label} type`),
+        primary_language: requiredSingleLine(payload.primary_language, `${label} primary language`),
+        framework: requiredSingleLine(payload.framework, `${label} framework`),
+        github_repository_binding_uid: optionalSingleLine(payload.github_repository_binding_uid, `${label} GitHubRepositoryBinding UID`),
+        branches: payload.branches.map((branch, index) => {
+            const item = requiredObject(branch, `${label}.branches[${index}]`);
+            return {
+                uid: requiredSingleLine(item.uid, `${label}.branches[${index}] UID`),
+                repository_branch: requiredSingleLine(item.repository_branch, `${label}.branches[${index}] repository branch`)
+            };
+        })
+    };
+}
+function codeRepositoryBranchFromResponse(value, label) {
+    const payload = requiredObject(value, label);
+    if (typeof payload.is_initialized !== 'boolean') {
+        throw new ApiError(`${label}.is_initialized must be a boolean.`);
+    }
+    return {
+        uid: requiredSingleLine(payload.uid, `${label} UID`),
+        code_repository_uid: requiredSingleLine(payload.code_repository_uid, `${label} CodeRepository UID`),
+        code_repository_name: requiredSingleLine(payload.code_repository_name, `${label} CodeRepository name`),
+        repository_branch: requiredSingleLine(payload.repository_branch, `${label} repository branch`),
+        github_repository_binding_uid: optionalSingleLine(payload.github_repository_binding_uid, `${label} GitHubRepositoryBinding UID`),
+        is_initialized: payload.is_initialized
+    };
+}
+function gitHubRepositoryBindingFromResponse(value, label) {
+    const payload = requiredObject(value, label);
+    return {
+        uid: requiredSingleLine(payload.uid, `${label} UID`),
+        code_repository_uid: requiredSingleLine(payload.code_repository_uid, `${label} CodeRepository UID`),
+        code_repository_name: requiredSingleLine(payload.code_repository_name, `${label} CodeRepository name`),
+        repo_name: requiredSingleLine(payload.repo_name, `${label} repository name`),
+        github_full_name: requiredSingleLine(payload.github_full_name, `${label} GitHub full name`),
+        git_ssh_url: optionalSingleLine(payload.git_ssh_url, `${label} SSH URL`),
+        git_repo_url: optionalSingleLine(payload.git_repo_url, `${label} Git URL`)
+    };
+}