@andorra-labs/code 0.0.0-stage → 0.1.4

package/dist/src/powershell-pool.js

@@ -0,0 +1,235 @@
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { StringDecoder } from 'node:string_decoder';
+import path from 'node:path';
+import { shellBaseEnv, stopProcessTree } from './shell.js';
+import { recordCommandTiming } from './command-metrics.js';
+const MAX_OUTPUT = 32_768;
+const IDLE_MS = 30_000;
+// An opt-in worker for short, noninteractive commands. Persistent workers do
+// not replace the isolated foreground shell, particularly for background jobs
+// or commands that consume stdin, modify runspace state, or call exit.
+const BOOTSTRAP = [
+    "$ErrorActionPreference = 'Continue'",
+    "$PSDefaultParameterValues['*:ErrorAction'] = 'Stop'",
+    "$ProgressPreference = 'SilentlyContinue'",
+    "[Console]::OutputEncoding = [Text.UTF8Encoding]::new($false)",
+    "$OutputEncoding = [Console]::OutputEncoding",
+    "while ($null -ne ($line = [Console]::In.ReadLine())) {",
+    "  $separator = $line.IndexOf(':')",
+    "  if ($separator -lt 1) { continue }",
+    "  $id = $line.Substring(0, $separator)",
+    "  $encoded = $line.Substring($separator + 1)",
+    "  $code = 0",
+    "  $global:LASTEXITCODE = 0",
+    "  try {",
+    "    $source = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($encoded))",
+    "    & ([ScriptBlock]::Create($source)) 2>&1 | ForEach-Object {",
+    "      if ($_ -is [System.Management.Automation.ErrorRecord]) {",
+    "        [Console]::Out.WriteLine($_.ToString())",
+    "        if ($_.FullyQualifiedErrorId -notin @('NativeCommandError', 'NativeCommandErrorMessage')) { $code = 1 }",
+    "      } else { [Console]::Out.WriteLine([string]$_) }",
+    "    }",
+    "    if ($code -eq 0 -and $null -ne $LASTEXITCODE) { $code = [int]$LASTEXITCODE }",
+    "  } catch { [Console]::Out.WriteLine($_.ToString()); $code = 1 }",
+    "  [Console]::Out.WriteLine(([char]30).ToString() + 'ANDORRA_DONE:' + $id + ':' + $code + ([char]31).ToString())",
+    "  [Console]::Out.Flush()",
+    "}",
+].join('\n');
+/** Internal command worker; constructor injection permits deterministic teardown tests. */
+export class PowerShellWorker {
+    workspace;
+    onClose;
+    terminate;
+    child;
+    runId = randomUUID();
+    stdoutDecoder = new StringDecoder('utf8');
+    stderrDecoder = new StringDecoder('utf8');
+    stdoutPending = '';
+    active;
+    chain = Promise.resolve();
+    idle;
+    closed = false;
+    /** Never discard the owned process until all descendants have been reaped. */
+    disposal;
+    get isClosing() { return this.closed; }
+    constructor(workspace, onClose, terminate = stopProcessTree) {
+        this.workspace = workspace;
+        this.onClose = onClose;
+        this.terminate = terminate;
+        const executable = path.join(process.env.SystemRoot ?? 'C:\\Windows', 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+        this.child = spawn(executable, [
+            '-NoLogo', '-NoProfile', '-NonInteractive', '-OutputFormat', 'Text',
+            '-EncodedCommand', Buffer.from(BOOTSTRAP, 'utf16le').toString('base64'),
+        ], {
+            cwd: workspace, env: shellBaseEnv(this.runId), windowsHide: true,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        this.child.stdout.on('data', (chunk) => this.onStdout(this.stdoutDecoder.write(chunk)));
+        this.child.stderr.on('data', (chunk) => this.append(this.stderrDecoder.write(chunk)));
+        this.child.on('error', error => { void this.dispose(error).catch(() => { }); });
+        this.child.on('close', () => { void this.dispose(new Error('Persistent PowerShell worker exited')).catch(() => { }); });
+    }
+    append(text) {
+        if (!this.active || !text)
+            return;
+        this.active.output += text;
+        if (this.active.output.length > MAX_OUTPUT) {
+            this.active.output = this.active.output.slice(-MAX_OUTPUT);
+            this.active.truncated = true;
+        }
+    }
+    onStdout(text) {
+        if (!this.active) {
+            this.stdoutPending = '';
+            return;
+        }
+        this.stdoutPending += text;
+        const prefix = '\u001eANDORRA_DONE:' + this.active.id + ':';
+        const start = this.stdoutPending.indexOf(prefix);
+        if (start < 0) {
+            const safeLength = Math.max(0, this.stdoutPending.length - prefix.length);
+            this.append(this.stdoutPending.slice(0, safeLength));
+            this.stdoutPending = this.stdoutPending.slice(safeLength);
+            return;
+        }
+        const end = this.stdoutPending.indexOf('\u001f', start + prefix.length);
+        if (end < 0)
+            return;
+        this.append(this.stdoutPending.slice(0, start));
+        const code = Number(this.stdoutPending.slice(start + prefix.length, end));
+        this.stdoutPending = '';
+        this.active.finish(Number.isInteger(code) ? code : 1);
+    }
+    execute(command, timeout, signal, launchPolicy) {
+        const doExecute = () => new Promise((resolve, reject) => {
+            if (this.closed) {
+                reject(new Error('PowerShell worker is unavailable'));
+                return;
+            }
+            signal.throwIfAborted();
+            if (launchPolicy()) {
+                void this.dispose().then(() => reject(new Error('PowerShell permissions changed before command launch')), reject);
+                return;
+            }
+            if (this.idle) {
+                clearTimeout(this.idle);
+                this.idle = undefined;
+            }
+            const id = randomUUID();
+            let settled = false;
+            const onAbort = () => fail(new Error('Persistent PowerShell command aborted'));
+            const timer = setTimeout(() => fail(new Error('Persistent PowerShell command timed out')), timeout);
+            const cleanup = () => {
+                clearTimeout(timer);
+                signal.removeEventListener('abort', onAbort);
+            };
+            const fail = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                // Never report the command as finished while its children may still be
+                // writing the workspace. Reuse the same in-flight teardown promise.
+                void this.dispose().then(() => reject(error), cleanupError => reject(new AggregateError([error, cleanupError], 'PowerShell failed and process cleanup failed')));
+            };
+            this.active = {
+                id, output: '', truncated: false,
+                fail,
+                finish: (code) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    cleanup();
+                    const active = this.active;
+                    this.active = undefined;
+                    this.idle = setTimeout(() => { void this.dispose(); }, IDLE_MS);
+                    this.idle.unref();
+                    const output = 'Exit code: ' + code + '\n' + active.output + (active.truncated ? '\n[output truncated]' : '');
+                    if (code === 0)
+                        resolve(output);
+                    else
+                        reject(new Error(output));
+                },
+            };
+            signal.addEventListener('abort', onAbort, { once: true });
+            this.child.stdin.write(id + ':' + Buffer.from(command, 'utf8').toString('base64') + '\n', error => {
+                if (error)
+                    fail(error);
+            });
+            if (signal.aborted)
+                onAbort();
+        });
+        const pending = this.chain.then(doExecute, doExecute);
+        this.chain = pending.then(() => { }, () => { });
+        return pending;
+    }
+    dispose(error = new Error('PowerShell worker disposed')) {
+        if (this.disposal)
+            return this.disposal;
+        this.closed = true;
+        if (this.idle) {
+            clearTimeout(this.idle);
+            this.idle = undefined;
+        }
+        // Create the promise *before* notifying the active command: its fail handler
+        // calls dispose again to await this same cleanup rather than starting a
+        // second taskkill or rejecting before the descendants have terminated.
+        this.disposal = Promise.resolve().then(async () => {
+            try {
+                await this.terminate(this.child, this.runId);
+            }
+            catch (cleanupError) {
+                this.child.kill();
+                throw cleanupError;
+            }
+        }).finally(this.onClose);
+        const active = this.active;
+        this.active = undefined;
+        active?.fail(error);
+        return this.disposal;
+    }
+}
+const workers = new Map();
+export async function runPooledPowerShell(command, workspace, timeout, signal, launchPolicy) {
+    if (process.platform !== 'win32')
+        throw new Error('Persistent PowerShell is Windows-only');
+    if (!command.trim() || command.includes('\0') || command.length > 32_000)
+        throw new Error('Invalid PowerShell command');
+    if (launchPolicy())
+        throw new Error('Persistent shell requires Full Access or approved escalation');
+    signal.throwIfAborted();
+    let worker = workers.get(workspace);
+    // A timed-out worker stays registered until its process tree is actually
+    // reaped. An unrelated next command must not race its cleanup.
+    if (worker?.isClosing) {
+        await worker.dispose();
+        worker = workers.get(workspace);
+    }
+    if (!worker) {
+        worker = new PowerShellWorker(workspace, () => workers.delete(workspace));
+        workers.set(workspace, worker);
+    }
+    if (launchPolicy()) {
+        await worker.dispose();
+        throw new Error('Persistent shell permission changed before execution');
+    }
+    const started = Date.now();
+    const collect = (exitCode, timedOut, aborted) => recordCommandTiming({
+        kind: 'pooled', durationMs: Date.now() - started, validationMs: 0,
+        spawnToCloseMs: Date.now() - started, cleanupMs: 0, timedOut, aborted, exitCode,
+    });
+    try {
+        const output = await worker.execute(command, timeout, signal, launchPolicy);
+        collect(0, false, false);
+        return output;
+    }
+    catch (error) {
+        collect(null, error instanceof Error && /timed out/.test(error.message), signal.aborted);
+        throw error;
+    }
+}
+export async function disposePooledPowerShell() {
+    await Promise.all([...workers.values()].map(worker => worker.dispose()));
+    workers.clear();
+}

package/dist/src/profile.d.ts

@@ -0,0 +1,80 @@
+/**
+ * The account's own profile.
+ *
+ * The email is the account's identity and is never editable here: changing it needs a verified
+ * address the service does not run. The other fields are display text the account owner types.
+ */
+export interface AccountProfile {
+    email?: string;
+    name?: string;
+    givenName?: string;
+    familyName?: string;
+    /** When the account itself last changed, which is the closest thing to "profile saved". */
+    accountUpdatedAt?: string;
+}
+/** The fields an owner may change. A field set to `null` is cleared. */
+export interface AccountProfilePatch {
+    name?: string | null;
+    givenName?: string | null;
+    familyName?: string | null;
+}
+export declare class ProfileUnavailableError extends Error {
+    constructor(message?: string);
+}
+/**
+ * Whether a profile request is about the account the credential names.
+ *
+ * The profile belongs to one account, and a form opened for one account must not read or write
+ * another: the credential can be swapped for another account while a request is in flight, and the
+ * token is acquired inside the request, so the request would otherwise run as the account that
+ * replaced the one the caller meant. The subject the caller names is therefore checked against
+ * the account the credential now names.
+ *
+ * Returns the reason the request must be refused, or undefined when it may proceed. A request
+ * that names no account is refused when the credential names one, so a signed-out call is not
+ * answered with somebody's profile.
+ */
+export declare function profileAccountCheck(expected: unknown, credential: {
+    subject: string;
+} | undefined): string | undefined;
+/**
+ * A request that names an account the credential does not.
+ *
+ * It is the caller's mistake rather than a transport failure: the request never left, and the
+ * caller has to name the right account rather than retry it.
+ */
+export declare class ProfileAccountError extends Error {
+    constructor(message?: string);
+}
+/**
+ * A field the account cannot store, refused before anything is sent.
+ *
+ * It is not the service's answer: the request never left, so this is the boundary's own verdict on
+ * text it will not hold.
+ */
+export declare class ProfileTextError extends Error {
+    constructor(message?: string);
+}
+export interface ProfileDependencies {
+    /**
+     * The access token and the account it belongs to, read as one operation.
+     *
+     * The two are one credential, and a request that names an account must be sure the token it is
+     * about to use belongs to that account: a sign-in between two reads would answer with another
+     * account's data.
+     */
+    credential(signal?: AbortSignal): Promise<{
+        token: string;
+        subject: string;
+    } | undefined>;
+    apiBaseUrl(): string;
+    fetch: typeof globalThis.fetch;
+}
+/** Display text a profile field may hold: bounded, printable, and free of format characters. */
+export declare function safeProfileText(value: unknown): string | undefined;
+/** Read the signed-in account's profile. */
+export declare function createProfileReader(deps: ProfileDependencies): (expectedSubject?: string, signal?: AbortSignal) => Promise<AccountProfile>;
+/** Save the profile fields the owner changed and return the profile as the service stored it. */
+export declare function createProfileWriter(deps: ProfileDependencies): (patch: AccountProfilePatch, expectedSubject?: string, signal?: AbortSignal) => Promise<AccountProfile>;
+export declare const loadProfile: (expectedSubject?: string, signal?: AbortSignal) => Promise<AccountProfile>;
+export declare const saveProfile: (patch: AccountProfilePatch, expectedSubject?: string, signal?: AbortSignal) => Promise<AccountProfile>;

package/dist/src/profile.js

@@ -0,0 +1,200 @@
+import { AUTH_REFRESH_BUDGET_MS, AuthError, getAuthConfiguration, getCredential } from './auth/index.js';
+export class ProfileUnavailableError extends Error {
+    constructor(message = 'The account service could not be reached.') { super(message); }
+}
+/**
+ * Whether a profile request is about the account the credential names.
+ *
+ * The profile belongs to one account, and a form opened for one account must not read or write
+ * another: the credential can be swapped for another account while a request is in flight, and the
+ * token is acquired inside the request, so the request would otherwise run as the account that
+ * replaced the one the caller meant. The subject the caller names is therefore checked against
+ * the account the credential now names.
+ *
+ * Returns the reason the request must be refused, or undefined when it may proceed. A request
+ * that names no account is refused when the credential names one, so a signed-out call is not
+ * answered with somebody's profile.
+ */
+export function profileAccountCheck(expected, credential) {
+    if (expected !== undefined && (typeof expected !== 'string' || !expected)) {
+        return 'subject must be a non-empty string';
+    }
+    if (credential === undefined)
+        return 'No account is signed in.';
+    if (expected !== undefined && credential.subject !== expected) {
+        return 'The signed-in account is not the one this request was made for.';
+    }
+    return undefined;
+}
+/**
+ * A request that names an account the credential does not.
+ *
+ * It is the caller's mistake rather than a transport failure: the request never left, and the
+ * caller has to name the right account rather than retry it.
+ */
+export class ProfileAccountError extends Error {
+    constructor(message = 'The signed-in account is not the one this request was made for.') { super(message); this.name = 'ProfileAccountError'; }
+}
+/**
+ * A field the account cannot store, refused before anything is sent.
+ *
+ * It is not the service's answer: the request never left, so this is the boundary's own verdict on
+ * text it will not hold.
+ */
+export class ProfileTextError extends Error {
+    constructor(message = 'Those details hold characters the account cannot store.') { super(message); this.name = 'ProfileTextError'; }
+}
+/** Display text a profile field may hold: bounded, printable, and free of format characters. */
+export function safeProfileText(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const text = value.trim();
+    // The limit is counted in characters, not in UTF-16 code units: the service counts code points,
+    // and a name of emoji is shorter than the same text's code units. Counting the same way keeps
+    // the client's answer and the service's the same for every text.
+    if (!text || [...text].length > 128)
+        return undefined;
+    // Control, format, surrogate, private-use and unassigned characters are display hazards: they
+    // can reorder a line or hide it without being visible in the field itself.
+    if (/[\p{Cc}\p{Cf}\p{Cs}\p{Co}\p{Cn}]/u.test(text))
+        return undefined;
+    return text;
+}
+function readProfile(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new ProfileUnavailableError('The account service returned an unreadable profile.');
+    const source = value;
+    const profile = {};
+    if (typeof source.email === 'string')
+        profile.email = source.email;
+    for (const [field, key] of [['name', 'name'], ['givenName', 'givenName'], ['familyName', 'familyName']]) {
+        const text = safeProfileText(source[key]);
+        if (text !== undefined)
+            profile[field] = text;
+    }
+    if (typeof source.accountUpdatedAt === 'string' && Number.isFinite(Date.parse(source.accountUpdatedAt))) {
+        profile.accountUpdatedAt = source.accountUpdatedAt;
+    }
+    return profile;
+}
+async function accountRequest(deps, path, init, expectedSubject, signal) {
+    signal?.throwIfAborted();
+    const tokenBudget = signal ? AbortSignal.any([signal, AbortSignal.timeout(AUTH_REFRESH_BUDGET_MS)]) : AbortSignal.timeout(AUTH_REFRESH_BUDGET_MS);
+    // The token and the account it belongs to are read as one answer, and the account is checked
+    // against the one the caller named: a sign-in between two reads would otherwise answer with
+    // another account's profile.
+    const credential = await deps.credential(tokenBudget);
+    if (!credential)
+        throw new ProfileUnavailableError('Please log in to view your profile.');
+    if (expectedSubject !== undefined && credential.subject !== expectedSubject) {
+        throw new ProfileAccountError('The signed-in account is not the one this request was made for.');
+    }
+    const token = credential.token;
+    const bounded = signal ? AbortSignal.any([signal, AbortSignal.timeout(5000)]) : AbortSignal.timeout(5000);
+    const base = new URL(deps.apiBaseUrl());
+    if (base.protocol !== 'https:' || base.username || base.password || base.search || base.hash) {
+        throw new ProfileUnavailableError('The account service is not configured.');
+    }
+    const response = await deps.fetch(`${base.href.replace(/\/+$/, '')}${path}`, {
+        method: init.method,
+        headers: { Authorization: `Bearer ${token}`, ...(init.body === undefined ? {} : { 'content-type': 'application/json' }) },
+        ...(init.body === undefined ? {} : { body: init.body }),
+        signal: bounded,
+        redirect: 'error',
+    });
+    if (!response.ok) {
+        await response.body?.cancel().catch(() => { });
+        if (response.status === 400)
+            throw new ProfileUnavailableError('Those details could not be saved. Check them and try again.');
+        // A service that answers "no such route" was reached: reporting it as unreachable sends the
+        // owner to their network settings over a deployment that has no profile routes yet.
+        if (response.status === 404 || response.status === 405 || response.status === 501) {
+            throw new ProfileUnavailableError('The account service does not serve profiles yet.');
+        }
+        throw new ProfileUnavailableError();
+    }
+    const reader = response.body?.getReader();
+    if (!reader)
+        throw new ProfileUnavailableError();
+    const chunks = [];
+    let size = 0;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            size += value.byteLength;
+            if (size > 16_384)
+                throw new ProfileUnavailableError();
+            chunks.push(value);
+        }
+    }
+    finally {
+        await reader.cancel().catch(() => { });
+        reader.releaseLock();
+    }
+    return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+}
+/** Read the signed-in account's profile. */
+export function createProfileReader(deps) {
+    return async (expectedSubject, signal) => {
+        try {
+            return readProfile(await accountRequest(deps, '/profile', { method: 'GET' }, expectedSubject, signal));
+        }
+        catch (error) {
+            signal?.throwIfAborted();
+            if (error instanceof ProfileUnavailableError || error instanceof ProfileAccountError)
+                throw error;
+            // A refused credential is the account's own answer, not a transport failure.
+            if (error instanceof AuthError && (error.code === 'login_required' || error.code === 'invalid_token')) {
+                throw new ProfileUnavailableError('Please log in to view your profile.');
+            }
+            throw new ProfileUnavailableError();
+        }
+    };
+}
+/** Save the profile fields the owner changed and return the profile as the service stored it. */
+export function createProfileWriter(deps) {
+    return async (patch, expectedSubject, signal) => {
+        const body = {};
+        for (const [field, key] of [['name', 'name'], ['givenName', 'givenName'], ['familyName', 'familyName']]) {
+            if (patch[field] === undefined)
+                continue;
+            const value = patch[field];
+            if (value === null) {
+                body[key] = null;
+                continue;
+            }
+            const text = safeProfileText(value);
+            // A nonempty value the boundary refuses is a mistake, not a clear: sending it as an empty string
+            // would silently delete the field the account already holds.
+            if (text === undefined) {
+                throw new ProfileTextError([...String(value)].length > 128
+                    ? `${field} is longer than 128 characters.`
+                    : `${field} holds characters the account cannot store.`);
+            }
+            body[key] = text;
+        }
+        try {
+            return readProfile(await accountRequest(deps, '/profile', { method: 'PUT', body: JSON.stringify(body) }, expectedSubject, signal));
+        }
+        catch (error) {
+            signal?.throwIfAborted();
+            // An account that changed under the request is the caller's mistake, not a transport failure,
+            // and the reader answers the same way: the caller has to name the right account.
+            if (error instanceof ProfileAccountError)
+                throw error;
+            if (error instanceof ProfileUnavailableError)
+                throw error;
+            throw new ProfileUnavailableError();
+        }
+    };
+}
+export const loadProfile = createProfileReader({
+    credential: getCredential, apiBaseUrl: () => getAuthConfiguration().apiBaseUrl,
+    fetch: (...args) => globalThis.fetch(...args),
+});
+export const saveProfile = createProfileWriter({
+    credential: getCredential, apiBaseUrl: () => getAuthConfiguration().apiBaseUrl,
+    fetch: (...args) => globalThis.fetch(...args),
+});

package/dist/src/provider-connection.d.ts

@@ -0,0 +1,36 @@
+import { type ProviderConfig } from './providers.js';
+/**
+ * One provider connection test, as a settings surface reports it.
+ *
+ * `ok` answers the only question the user asked — did the endpoint accept this configuration — and
+ * the remaining fields explain what the endpoint said when it answered. `error` is a fixed phrase,
+ * never the endpoint's own body: an error body is untrusted input and may echo credentials.
+ */
+export interface ProviderConnectionTest {
+    ok: boolean;
+    latencyMs: number;
+    modelCount?: number;
+    /** Whether the provider's active model appeared in the listing; omitted when there is none to look for. */
+    modelAvailable?: boolean;
+    /** False when a public catalog cannot validate the saved credential. */
+    authenticationVerified?: boolean;
+    error?: string;
+}
+interface TestDeps {
+    fetch?: typeof fetch;
+    /** Codex has no HTTP endpoint to probe; its own sign-in state and model listing are the connection check. */
+    codexCatalog?: (signal: AbortSignal) => Promise<{
+        signedIn: boolean;
+        models: string[];
+    }>;
+}
+/**
+ * Probe one provider exactly the way a run would reach it: same base URL, same credential
+ * resolution, same request shape, a `GET /models` under a short bound of its own.
+ *
+ * The listing is the cheapest request that still exercises everything a misconfiguration breaks —
+ * DNS, TLS, the path, and the credential — without spending tokens. `signal` stays the caller's
+ * cancellation; the deadline armed here is reported as a failed test, not as something the user did.
+ */
+export declare function testProviderConnection(provider: ProviderConfig, signal: AbortSignal, deps?: TestDeps): Promise<ProviderConnectionTest>;
+export {};