orizu 0.5.49 → 0.5.50

package/dist/hosted-session-seed.js

@@ -16,6 +16,8 @@
  * Credentials come only through the `-c` settings the caller passes (the
  * boot's credential helper), never in a URL or argument.
  */
+import { existsSync, readdirSync, renameSync } from 'fs';
+import { join } from 'path';
 export const SESSION_COPY_SEED_FAILURE = 'session copy could not be filled from the team copy';
 function withConfig(config) {
     return config.flatMap(setting => ['-c', setting]);
@@ -120,16 +122,31 @@ export async function cloneTeamIntoWorkTree(input) {
         const pointed = input.exec('git', ['-C', input.scratchDir, 'remote', 'set-url', 'origin', input.sessionRemote]);
         if (pointed.status !== 0)
             throw failure('pointing the working folder at the session copy', pointed);
-        // The runtime image may ship the folder empty; `mv` needs it gone.
-        input.exec('rmdir', ['--', input.workTree]);
-        // A folder that is still there (not empty, or a mount point) would make
-        // `mv` put the clone inside it.
-        const remaining = input.exec('test', ['-e', input.workTree]);
-        if (remaining.status === 0)
-            throw failure('making the working folder', { status: 1, stdout: '', stderr: `${input.workTree} is not empty` });
-        const moved = input.exec('mv', ['--', input.scratchDir, input.workTree]);
-        if (moved.status !== 0)
-            throw failure('making the working folder', moved);
+        // ORI-2512: an existing folder (the runtime image may ship it empty, and
+        // the boot may have started OpenCode in it) is filled in place, never
+        // replaced: a process already started there would be left in a deleted
+        // folder. A missing folder becomes the clone.
+        if (existsSync(input.workTree)) {
+            if (readdirSync(input.workTree).length > 0)
+                throw failure('making the working folder', { status: 1, stdout: '', stderr: `${input.workTree} is not empty` });
+            try {
+                // `.git` last: a fill that stops partway leaves no repository, which
+                // the next boot refuses, rather than one missing files that a save
+                // would push as deleted.
+                const entries = readdirSync(input.scratchDir).sort((a, b) => Number(a === '.git') - Number(b === '.git'));
+                const rename = input.rename ?? renameSync;
+                for (const entry of entries)
+                    rename(join(input.scratchDir, entry), join(input.workTree, entry));
+            }
+            catch (error) {
+                throw failure('making the working folder', { status: 1, stdout: '', stderr: error instanceof Error ? error.message : String(error) });
+            }
+        }
+        else {
+            const moved = input.exec('mv', ['--', input.scratchDir, input.workTree]);
+            if (moved.status !== 0)
+                throw failure('making the working folder', moved);
+        }
     }
     finally {
         clear();

package/dist/http.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../src/http.ts"],"names":[],"mappings":"AAWA,OAAO,EAAsC,WAAW,EAAoB,MAAM,mBAAmB,CAAA;AAerG,wBAAgB,sBAAsB,IAAI,MAAM,GAAG,IAAI,CAEtD;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,WAAW,QAGhD;AAED,wBAAgB,cAAc,CAAC,KAAK,GAAE,WAA0B,GAAG,MAAM,CAiBxE;AAED,UAAU,YAAY;IACpB,OAAO,EAAE,MAAM,CAAA;IACf,iBAAiB,EAAE,MAAM,CAAA;CAC1B;AAID,wBAAgB,mBAAmB,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,YAAY,CAMnE;AAED,UAAU,WAAW;IACnB,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,OAAO,CAAA;CACnB;AAED,wBAAgB,kBAAkB,CAAC,KAAK,GAAE,WAA0B,GAAG,WAAW,CAajF;AAED,wBAAgB,mBAAmB,CAAC,KAAK,GAAE,WAA0B,GAAG,MAAM,CAE7E;AAED,wBAAgB,UAAU,IAAI,MAAM,CAEnC;AAWD,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,MAAM,QAmBzD;AA+FD,wBAAgB,+BAA+B,IAAI,IAAI,CAAC,WAAW,EAAE,UAAU,CAAC,CAE/E;AAmGD,MAAM,MAAM,0BAA0B,GAAG,aAAa,GAAG,kBAAkB,GAAG,QAAQ,CAAA;AAEtF,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,MAAM,EAAE,0BAA0B,CAAA;IAC3C,sFAAsF;IACtF,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,EAAE,cAAc,CAAC,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAA;IACvF,MAAM,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAA;CAC3D;AAED,MAAM,WAAW,YAAY;IAC3B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,sBAAsB,EAAE,OAAO,CAAA;CAChC;AAED;;;;;GAKG;AACH,wBAAgB,kCAAkC,CAChD,OAAO,GAAE;IAAE,YAAY,CAAC,EAAE,OAAO,CAAC;IAAC,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAAO,GACpE,2BAA2B,CAoI7B;AAID,wBAAsB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,WAAgB,EAAE,cAAc,CAAC,EAAE,MAAM,IAAI,qBAqElG"}
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../src/http.ts"],"names":[],"mappings":"AAOA,OAAO,EAAsC,WAAW,EAAoB,MAAM,mBAAmB,CAAA;AAWrG,wBAAgB,sBAAsB,IAAI,MAAM,GAAG,IAAI,CAEtD;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,WAAW,QAGhD;AAED,wBAAgB,cAAc,CAAC,KAAK,GAAE,WAA0B,GAAG,MAAM,CAiBxE;AAED,UAAU,YAAY;IACpB,OAAO,EAAE,MAAM,CAAA;IACf,iBAAiB,EAAE,MAAM,CAAA;CAC1B;AAID,wBAAgB,mBAAmB,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,YAAY,CAMnE;AAED,UAAU,WAAW;IACnB,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,OAAO,CAAA;CACnB;AAED,wBAAgB,kBAAkB,CAAC,KAAK,GAAE,WAA0B,GAAG,WAAW,CAajF;AAED,wBAAgB,mBAAmB,CAAC,KAAK,GAAE,WAA0B,GAAG,MAAM,CAE7E;AAED,wBAAgB,UAAU,IAAI,MAAM,CAEnC;AAWD,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,MAAM,QAmBzD;AAED,wBAAgB,+BAA+B,IAAI,IAAI,CAAC,WAAW,EAAE,UAAU,CAAC,CAE/E;AAID,MAAM,MAAM,0BAA0B,GAAG,aAAa,GAAG,kBAAkB,GAAG,QAAQ,CAAA;AAEtF,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,MAAM,EAAE,0BAA0B,CAAA;IAC3C,sFAAsF;IACtF,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,EAAE,cAAc,CAAC,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAA;IACvF,MAAM,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAA;CAC3D;AAED,MAAM,WAAW,YAAY;IAC3B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,sBAAsB,EAAE,OAAO,CAAA;CAChC;AAMD;;;;;GAKG;AACH,wBAAgB,kCAAkC,CAChD,OAAO,GAAE;IAAE,YAAY,CAAC,EAAE,OAAO,CAAC;IAAC,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAAO,GACpE,2BAA2B,CAqE7B;AAcD,wBAAsB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,WAAgB,EAAE,cAAc,CAAC,EAAE,MAAM,IAAI,qBAoClG"}

package/dist/http.js

@@ -1,6 +1,5 @@
-import { clearServerCredentialsIfCurrent, credentialsEqual, resolveCredentialServer, getActiveBaseUrl, getServerCredentials, rememberResolvedBearer, resolveEnvBearerToken, updateServerCredentialsIfCurrent, withCredentialsTransactionLockAsync, } from './credentials.js';
+import { resolveCredentialServer, getActiveBaseUrl, getServerCredentials, rememberResolvedBearer, resolveEnvBearerToken, } from './credentials.js';
 import { canonicalServerUrl, getFlagBaseUrl, normalizeBaseUrl } from './global-flags.js';
-import { describeLogoutHttpFailure, describeLogoutTransportFailure, } from './logout-diagnostic.js';
 let runtimeFlags = { local: false, server: null };
 let lastResolvedBaseUrl = null;
 function rememberResolvedBaseUrl(baseUrl) {
@@ -78,141 +77,12 @@ export function assertSecureTokenTransport(baseUrl) {
     }
     throw new Error(`Refusing to send CLI tokens to ${baseUrl}. Use HTTPS, or --local for loopback development.`);
 }
-function isSessionCredentials(credentials) {
-    return 'accessToken' in credentials;
-}
-function getAuthorizationToken(credentials) {
-    return isSessionCredentials(credentials)
-        ? rememberSessionCredentials(credentials).accessToken
-        : rememberResolvedBearer(credentials.apiKey);
-}
-function rememberSessionCredentials(credentials) {
-    rememberResolvedBearer(credentials.accessToken);
-    rememberResolvedBearer(credentials.refreshToken);
-    return credentials;
-}
-function isExpired(expiresAt) {
-    const nowUnix = Math.floor(Date.now() / 1000);
-    return expiresAt <= nowUnix + 30;
-}
-const DEFAULT_CREDENTIALS_REFRESH_TIMEOUT_MS = 10_000;
-const MAX_CREDENTIALS_REFRESH_TIMEOUT_MS = 30_000;
-const DEFAULT_LOGOUT_TIMEOUT_MS = 10_000;
-const MAX_LOGOUT_TIMEOUT_MS = 30_000;
-function getCredentialsRefreshTimeoutMs() {
-    const configured = Number(process.env.ORIZU_CREDENTIALS_REFRESH_TIMEOUT_MS);
-    if (!Number.isSafeInteger(configured) || configured <= 0) {
-        return DEFAULT_CREDENTIALS_REFRESH_TIMEOUT_MS;
-    }
-    return Math.min(configured, MAX_CREDENTIALS_REFRESH_TIMEOUT_MS);
-}
-function getLogoutTimeoutMs() {
-    const configured = Number(process.env.ORIZU_LOGOUT_TIMEOUT_MS);
-    if (!Number.isSafeInteger(configured) || configured <= 0) {
-        return DEFAULT_LOGOUT_TIMEOUT_MS;
-    }
-    return Math.min(configured, MAX_LOGOUT_TIMEOUT_MS);
-}
-async function withAbortDeadline(operation, callerSignal, timeoutMs, timeoutError) {
-    const controller = new AbortController();
-    const handleCallerAbort = () => controller.abort(callerSignal?.reason);
-    if (callerSignal?.aborted)
-        handleCallerAbort();
-    else
-        callerSignal?.addEventListener('abort', handleCallerAbort, { once: true });
-    const timer = setTimeout(() => controller.abort(timeoutError), timeoutMs);
-    const cancellation = new Promise((_resolve, reject) => {
-        const handleAbort = () => reject(controller.signal.reason ?? new Error('Request aborted.'));
-        if (controller.signal.aborted)
-            handleAbort();
-        else
-            controller.signal.addEventListener('abort', handleAbort, { once: true });
-    });
-    try {
-        return await Promise.race([operation(controller.signal), cancellation]);
-    }
-    finally {
-        clearTimeout(timer);
-        callerSignal?.removeEventListener('abort', handleCallerAbort);
-    }
-}
-async function withCredentialsRefreshDeadline(operation, callerSignal) {
-    const timeoutMs = getCredentialsRefreshTimeoutMs();
-    const timeoutError = new Error(`ORIZU_CREDENTIALS_REFRESH_TIMEOUT: session refresh exceeded ${timeoutMs}ms.`);
-    return await withAbortDeadline(operation, callerSignal, timeoutMs, timeoutError);
-}
-async function withLogoutDeadline(operation, callerSignal) {
-    const timeoutMs = getLogoutTimeoutMs();
-    const timeoutError = new Error(`ORIZU_LOGOUT_TIMEOUT: remote logout exceeded ${timeoutMs}ms.`);
-    timeoutError.name = 'TimeoutError';
-    return await withAbortDeadline(operation, callerSignal, timeoutMs, timeoutError);
-}
 export function credentialRequestRedirectPolicy() {
     return process.env.ORIZU_CLI_AUTH_REDIRECT === 'error' ? { redirect: 'error' } : {};
 }
-async function refreshCredentials(baseUrl, credentials, callerSignal) {
-    if (!isSessionCredentials(credentials)) {
-        throw new Error('API key credentials do not refresh. Run `orizu login` again if access fails.');
-    }
-    assertSecureTokenTransport(baseUrl);
-    const refreshToken = rememberResolvedBearer(credentials.refreshToken);
-    const data = await withCredentialsRefreshDeadline(async (signal) => {
-        const response = await fetch(`${baseUrl}/api/cli/auth/refresh`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ refreshToken }),
-            ...credentialRequestRedirectPolicy(),
-            signal,
-        });
-        if (!response.ok) {
-            throw new Error('Session expired. Run `orizu login` again.');
-        }
-        return await response.json();
-    }, callerSignal);
-    if (!data.accessToken || !data.refreshToken || !data.expiresAt) {
-        throw new Error('Server returned invalid refresh credentials. Run `orizu login` again.');
-    }
-    const refreshed = rememberSessionCredentials({
-        credentialType: 'session',
-        accessToken: data.accessToken,
-        refreshToken: data.refreshToken,
-        expiresAt: data.expiresAt,
-    });
-    if (isExpired(refreshed.expiresAt)) {
-        throw new Error('ORIZU_CREDENTIALS_REFRESH_UNUSABLE: refreshed session expires within the 30-second safety window.');
-    }
-    return refreshed;
-}
-async function refreshStoredCredentialsIfCurrent(baseUrl, expected, callerSignal) {
-    return await withCredentialsTransactionLockAsync(async () => {
-        const current = getServerCredentials(baseUrl);
-        if (!current || !credentialsEqual(current, expected)) {
-            return { status: 'changed', credentials: current };
-        }
-        const refreshed = await refreshCredentials(baseUrl, expected, callerSignal);
-        if (!updateServerCredentialsIfCurrent(baseUrl, expected, refreshed)) {
-            return { status: 'changed', credentials: getServerCredentials(baseUrl) };
-        }
-        return { status: 'refreshed', credentials: refreshed };
-    });
-}
-function requireCurrentCredentials(baseUrl, credentials) {
-    if (credentials)
-        return credentials;
-    throw new Error(`Not logged in for ${baseUrl}. Run \`orizu login --server ${baseUrl}\` (or \`--local\`) first.`);
-}
-async function refreshExpiredStoredCredentials(baseUrl, initial, callerSignal) {
-    if (!isSessionCredentials(initial) || !isExpired(initial.expiresAt)) {
-        return { credentials: initial, didRefresh: false };
-    }
-    const result = await refreshStoredCredentialsIfCurrent(baseUrl, initial, callerSignal);
-    if (result.status === 'changed') {
-        throw new Error('ORIZU_AUTH_CONTEXT_CHANGED: stored credentials changed before this request began; the request was not sent.');
-    }
-    return {
-        credentials: requireCurrentCredentials(baseUrl, result.credentials),
-        didRefresh: true,
-    };
+const storedSessionRequests = () => import('./stored-session-requests.js');
+function notLoggedIn(baseUrl) {
+    return new Error(`Not logged in for ${baseUrl}. Run \`orizu login --server ${baseUrl}\` (or \`--local\`) first.`);
 }
 /**
  * Captures one authenticated server context for a multi-step operation. The
@@ -266,85 +136,41 @@ export function captureAuthenticatedRequestContext(options = {}) {
         };
     }
     const capturedCredentials = getServerCredentials(baseUrl);
-    if (!capturedCredentials) {
-        throw new Error(`Not logged in for ${baseUrl}. Run \`orizu login --server ${baseUrl}\` (or \`--local\`) first.`);
-    }
-    void getAuthorizationToken(capturedCredentials);
+    if (!capturedCredentials)
+        throw notLoggedIn(baseUrl);
+    rememberStoredBearers(capturedCredentials);
     let activeCredentials = capturedCredentials;
-    async function refreshCapturedCredentials(callerSignal) {
-        const result = await refreshStoredCredentialsIfCurrent(baseUrl, activeCredentials, callerSignal);
-        if (result.status === 'changed') {
-            throw new Error('ORIZU_CREDENTIALS_CHANGED: stored credentials changed before the captured session could refresh. Reconfirm the account and retry.');
-        }
-        activeCredentials = requireCurrentCredentials(baseUrl, result.credentials);
-    }
+    const changed = 'ORIZU_CREDENTIALS_CHANGED: stored credentials changed before the captured session could refresh. Reconfirm the account and retry.';
     return {
         baseUrl,
         source: 'stored',
         async fetch(path, init = {}, onRequestStart) {
-            let didRefresh = false;
-            if (allowRefresh
-                && isSessionCredentials(activeCredentials)
-                && isExpired(activeCredentials.expiresAt)) {
-                await refreshCapturedCredentials(init.signal);
-                didRefresh = true;
-            }
-            onRequestStart?.();
-            let response = await fetch(`${baseUrl}${path}`, {
-                ...init,
-                headers: {
-                    ...(init.headers || {}),
-                    Authorization: `Bearer ${getAuthorizationToken(activeCredentials)}`,
-                },
-                ...credentialRequestRedirectPolicy(),
-            });
-            if (allowRefresh
-                && response.status === 401
-                && isSessionCredentials(activeCredentials)
-                && !didRefresh) {
-                await refreshCapturedCredentials(init.signal);
-                onRequestStart?.();
-                response = await fetch(`${baseUrl}${path}`, {
-                    ...init,
-                    headers: {
-                        ...(init.headers || {}),
-                        Authorization: `Bearer ${getAuthorizationToken(activeCredentials)}`,
-                    },
-                    ...credentialRequestRedirectPolicy(),
-                });
-            }
-            return response;
+            const { storedRequest } = await storedSessionRequests();
+            return await storedRequest({
+                baseUrl,
+                credentials: activeCredentials,
+                allowRefresh,
+                changedBeforeRequest: changed,
+                changedBeforeReplay: changed,
+                onRefreshed: refreshed => { activeCredentials = refreshed; },
+            }, path, init, onRequestStart);
         },
         async logout(callerSignal) {
-            const authorizationToken = getAuthorizationToken(activeCredentials);
-            const refreshToken = isSessionCredentials(activeCredentials)
-                ? rememberResolvedBearer(activeCredentials.refreshToken)
-                : null;
-            const secrets = [authorizationToken, ...(refreshToken !== null ? [refreshToken] : [])];
-            let remoteLogoutReason = null;
-            try {
-                remoteLogoutReason = await withLogoutDeadline(async (signal) => {
-                    const response = await fetch(`${baseUrl}/api/cli/auth/logout`, {
-                        method: 'POST',
-                        headers: {
-                            'Content-Type': 'application/json',
-                            Authorization: `Bearer ${authorizationToken}`,
-                        },
-                        body: refreshToken !== null ? JSON.stringify({ refreshToken }) : undefined,
-                        ...credentialRequestRedirectPolicy(),
-                        signal,
-                    });
-                    return response.ok ? null : await describeLogoutHttpFailure(response, secrets);
-                }, callerSignal);
-            }
-            catch (error) {
-                remoteLogoutReason = describeLogoutTransportFailure(error, secrets);
-            }
-            const localCredentialCleared = clearServerCredentialsIfCurrent(baseUrl, activeCredentials);
-            return { remoteError: remoteLogoutReason, localCredentialCleared };
+            const { storedLogout } = await storedSessionRequests();
+            return await storedLogout(baseUrl, baseUrl, activeCredentials, callerSignal);
         },
     };
 }
+// Redacts a stored login from diagnostics from the moment it is read.
+function rememberStoredBearers(credentials) {
+    if ('accessToken' in credentials) {
+        rememberResolvedBearer(credentials.accessToken);
+        rememberResolvedBearer(credentials.refreshToken);
+    }
+    else {
+        rememberResolvedBearer(credentials.apiKey);
+    }
+}
 // The optional observer runs immediately before a resource fetch, after auth
 // preflight. Authentication refresh requests do not mark the resource as sent.
 export async function authedFetch(path, init = {}, onRequestStart) {
@@ -371,35 +197,14 @@ export async function authedFetch(path, init = {}, onRequestStart) {
         });
     }
     const credentials = getServerCredentials(baseUrl);
-    if (!credentials) {
-        throw new Error(`Not logged in for ${baseUrl}. Run \`orizu login --server ${baseUrl}\` (or \`--local\`) first.`);
-    }
-    const resolved = await refreshExpiredStoredCredentials(baseUrl, credentials, init.signal);
-    let activeCredentials = resolved.credentials;
-    let response = await fetchResource(`${baseUrl}${path}`, {
-        ...init,
-        headers: {
-            ...(init.headers || {}),
-            Authorization: `Bearer ${getAuthorizationToken(activeCredentials)}`,
-        },
-        ...credentialRequestRedirectPolicy(),
-    });
-    if (response.status === 401
-        && isSessionCredentials(activeCredentials)
-        && !resolved.didRefresh) {
-        const refreshResult = await refreshStoredCredentialsIfCurrent(baseUrl, activeCredentials, init.signal);
-        if (refreshResult.status === 'changed') {
-            throw new Error('ORIZU_AUTH_CONTEXT_CHANGED: stored credentials changed after this request began; the request was not replayed.');
-        }
-        activeCredentials = requireCurrentCredentials(baseUrl, refreshResult.credentials);
-        response = await fetchResource(`${baseUrl}${path}`, {
-            ...init,
-            headers: {
-                ...(init.headers || {}),
-                Authorization: `Bearer ${getAuthorizationToken(activeCredentials)}`,
-            },
-            ...credentialRequestRedirectPolicy(),
-        });
-    }
-    return response;
+    if (!credentials)
+        throw notLoggedIn(baseUrl);
+    const { storedRequest } = await storedSessionRequests();
+    return await storedRequest({
+        baseUrl,
+        credentials,
+        allowRefresh: true,
+        changedBeforeRequest: 'ORIZU_AUTH_CONTEXT_CHANGED: stored credentials changed before this request began; the request was not sent.',
+        changedBeforeReplay: 'ORIZU_AUTH_CONTEXT_CHANGED: stored credentials changed after this request began; the request was not replayed.',
+    }, path, init, onRequestStart);
 }

package/dist/keyboard-select.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"keyboard-select.d.ts","sourceRoot":"","sources":["../src/keyboard-select.ts"],"names":[],"mappings":"AAUA,UAAU,qBAAqB,CAAC,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC,CAAA;IAClB,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAOD,wBAAsB,oBAAoB,CAAC,CAAC,EAC1C,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,CAAC,EAAE,EACV,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,EACzC,OAAO,CAAC,EAAE,qBAAqB,CAAC,CAAC,CAAC,GACjC,OAAO,CAAC,CAAC,CAAC,CAuEZ"}
+{"version":3,"file":"keyboard-select.d.ts","sourceRoot":"","sources":["../src/keyboard-select.ts"],"names":[],"mappings":"AAIA,UAAU,qBAAqB,CAAC,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC,CAAA;IAClB,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAED,wBAAsB,oBAAoB,CAAC,CAAC,EAC1C,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,CAAC,EAAE,EACV,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,EACzC,OAAO,CAAC,EAAE,qBAAqB,CAAC,CAAC,CAAC,GACjC,OAAO,CAAC,CAAC,CAAC,CA6CZ"}

package/dist/keyboard-select.js

@@ -1,4 +1,3 @@
-import { emitKeypressEvents } from 'readline';
 import { stdin as input, stdout as output } from 'process';
 import { sanitizeTerminalText } from './json-response.js';
 export async function promptKeyboardSelect(title, items, label, options) {
@@ -12,9 +11,6 @@ export async function promptKeyboardSelect(title, items, label, options) {
     output.write(`Use ↑/↓ to choose, Enter to confirm, or Esc to ${options?.escapeLabel || 'cancel'}.\n`);
     let selected = 0;
     let rendered = false;
-    const rawInput = input;
-    const wasRaw = Boolean(rawInput.isRaw);
-    emitKeypressEvents(input);
     function render() {
         if (rendered)
             output.write(`\x1b[${items.length}A`);
@@ -26,47 +22,29 @@ export async function promptKeyboardSelect(title, items, label, options) {
         rendered = true;
     }
     render();
-    output.write('\x1b[?25l');
-    return new Promise((resolvePromise, rejectPromise) => {
-        function cleanup() {
-            input.off('keypress', onKeypress);
-            if (rawInput.setRawMode && !wasRaw)
-                rawInput.setRawMode(false);
-            input.pause();
-            output.write('\x1b[?25h\n');
-        }
-        function onKeypress(_chunk, key) {
-            if (key.ctrl && key.name === 'c') {
-                cleanup();
-                rejectPromise(new Error('Setup cancelled.'));
-                return;
-            }
-            if (key.name === 'escape') {
-                cleanup();
-                if (options?.onEscape)
-                    resolvePromise(options.onEscape());
-                else
-                    rejectPromise(new Error('Setup cancelled.'));
-                return;
-            }
-            if (key.name === 'up') {
-                selected = (selected - 1 + items.length) % items.length;
-                render();
-                return;
-            }
-            if (key.name === 'down') {
-                selected = (selected + 1) % items.length;
+    const onEscape = options?.onEscape;
+    const { readKeys } = await import('./terminal-key-session.js');
+    let choice;
+    try {
+        choice = await readKeys(key => {
+            if (key.name === 'escape')
+                return onEscape ? { kind: 'done', value: { escaped: true } } : { kind: 'cancel' };
+            if (key.name === 'up' || key.name === 'down') {
+                selected = (selected + (key.name === 'up' ? -1 : 1) + items.length) % items.length;
                 render();
-                return;
+                return { kind: 'wait' };
             }
-            if (key.name === 'return' || key.name === 'enter') {
-                const item = items[selected];
-                cleanup();
-                resolvePromise(item);
-            }
-        }
-        input.on('keypress', onKeypress);
-        input.resume();
-        rawInput.setRawMode?.(true);
-    });
+            if (key.name === 'return' || key.name === 'enter')
+                return { kind: 'done', value: { item: items[selected] } };
+            return { kind: 'wait' };
+        }, { hideCursor: true });
+    }
+    finally {
+        output.write('\n');
+    }
+    if ('item' in choice)
+        return choice.item;
+    if (!onEscape)
+        throw new Error('Setup cancelled.');
+    return onEscape();
 }

package/dist/project-create-workflow.d.ts

@@ -0,0 +1,18 @@
+/** Sends one request; calls `onRequestStart` just before anything goes out. */
+export type ProjectCreateRequest = (path: string, init: RequestInit, onRequestStart?: () => void) => Promise<Response>;
+export interface CreatedProject {
+    id: string;
+    name: string;
+    slug: string;
+    teamId: string;
+    teamName: string;
+    teamSlug: string;
+    role: string;
+}
+/**
+ * `orizu projects create` and setup's project create: one request with a time
+ * limit, never retried, since a retry after an unclear outcome could make a
+ * second project. When the outcome is unclear, the error says how to check.
+ */
+export declare function createProjectWithDeadline(teamSlug: string, name: string, request: ProjectCreateRequest): Promise<CreatedProject>;
+//# sourceMappingURL=project-create-workflow.d.ts.map

package/dist/project-create-workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-create-workflow.d.ts","sourceRoot":"","sources":["../src/project-create-workflow.ts"],"names":[],"mappings":"AASA,+EAA+E;AAC/E,MAAM,MAAM,oBAAoB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,cAAc,CAAC,EAAE,MAAM,IAAI,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAA;AActH,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;CACb;AAmDD;;;;GAIG;AACH,wBAAsB,yBAAyB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,cAAc,CAAC,CAkDtI"}

package/dist/project-create-workflow.js

@@ -0,0 +1,121 @@
+import { Cause, Effect, Exit, Result, Schema } from 'effect';
+import { datasetTransferTimeoutMs } from './dataset-transfer-policy.js';
+import { extractErrorMessage } from './error-response.js';
+import { appErrorOf, unreachedCode } from './request-outcome.js';
+const CreateReply = Schema.Struct({
+    project: Schema.Struct({
+        id: Schema.NonEmptyString,
+        name: Schema.String,
+        slug: Schema.NonEmptyString,
+        teamSlug: Schema.NonEmptyString,
+        teamId: Schema.optional(Schema.String),
+        teamName: Schema.optional(Schema.String),
+        role: Schema.optional(Schema.String),
+    }),
+});
+/**
+ * Runs one request under the time limit. `run` gets the signal to pass on and
+ * the hook that marks the request as sent; the body is read inside `run`, so a
+ * reply that stalls part way is under the limit too.
+ */
+function withDeadline(timeoutMs, run, onFailure) {
+    return Effect.suspend(() => {
+        let sent = false;
+        let timedOut = false;
+        return Effect.tryPromise({
+            try: async (signal) => {
+                const controller = new AbortController();
+                const abort = () => controller.abort();
+                const timer = setTimeout(() => { timedOut = true; controller.abort(); }, timeoutMs);
+                if (signal.aborted)
+                    abort();
+                else
+                    signal.addEventListener('abort', abort, { once: true });
+                try {
+                    return await run(controller.signal, () => { sent = true; });
+                }
+                finally {
+                    clearTimeout(timer);
+                    signal.removeEventListener('abort', abort);
+                    controller.abort();
+                }
+            },
+            catch: cause => onFailure(cause, { timedOut, sent }),
+        });
+    });
+}
+async function runToPromise(effect) {
+    const exit = await Effect.runPromiseExit(effect);
+    if (Exit.isSuccess(exit))
+        return exit.value;
+    throw Cause.squash(exit.cause);
+}
+const FAILED = 'Failed to create project';
+const projectMayBeCreated = (teamSlug, name) => `The project may already be created: run \`orizu projects list --team ${teamSlug}\` and look for "${name}" before creating it again.`;
+class ProjectCreateFailure extends Error {
+    mayBeCreated;
+    _tag = 'ProjectCreateFailure';
+    constructor(message, mayBeCreated) {
+        super(message);
+        this.mayBeCreated = mayBeCreated;
+    }
+}
+/**
+ * `orizu projects create` and setup's project create: one request with a time
+ * limit, never retried, since a retry after an unclear outcome could make a
+ * second project. When the outcome is unclear, the error says how to check.
+ */
+export async function createProjectWithDeadline(teamSlug, name, request) {
+    const create = withDeadline(datasetTransferTimeoutMs(), async (signal, markSent) => {
+        const response = await request('/api/cli/projects', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ teamSlug, name }),
+            signal,
+        }, markSent);
+        if (!response.ok) {
+            const appError = await appErrorOf(response.clone());
+            const detail = await extractErrorMessage(response);
+            // A 5xx that is not the app's own error may come from a gateway that gave up while the app kept working.
+            if (response.status < 400 || (response.status >= 500 && appError === null)) {
+                throw new ProjectCreateFailure(`Project create got no clear answer (status ${response.status}).`, true);
+            }
+            throw new ProjectCreateFailure(detail.startsWith(FAILED) ? detail : `${FAILED}: ${detail}`, false);
+        }
+        const body = await response.text();
+        let data;
+        try {
+            data = JSON.parse(body);
+        }
+        catch {
+            data = undefined;
+        }
+        const decoded = Schema.decodeUnknownResult(CreateReply)(data);
+        if (Result.isFailure(decoded)) {
+            throw new ProjectCreateFailure(`Project create returned an unexpected response (status ${response.status}).`, true);
+        }
+        const project = decoded.success.project;
+        return {
+            id: project.id,
+            name: project.name,
+            slug: project.slug,
+            teamId: project.teamId || '',
+            teamName: project.teamName || project.teamSlug,
+            teamSlug: project.teamSlug,
+            role: project.role || 'admin',
+        };
+    }, (cause, { timedOut, sent }) => {
+        if (cause instanceof ProjectCreateFailure)
+            return cause;
+        if (timedOut)
+            return new ProjectCreateFailure('Project create exceeded its deadline.', sent);
+        const unreached = unreachedCode(cause);
+        if (unreached)
+            return new ProjectCreateFailure(`${FAILED}: could not reach the server (${unreached}).`, false);
+        const message = cause instanceof Error ? cause.message : String(cause);
+        if (!sent || message.startsWith('ORIZU_AUTH_CONTEXT_CHANGED:'))
+            return new ProjectCreateFailure(message, false);
+        return new ProjectCreateFailure(`Project create did not finish: ${message}`, true);
+    });
+    return await runToPromise(create.pipe(Effect.mapError(failure => new Error(failure.mayBeCreated ? `${failure.message}\n${projectMayBeCreated(teamSlug, name)}` : failure.message))));
+}

package/dist/self-update-command.d.ts

@@ -0,0 +1,8 @@
+import { type GlobalInstall, type SelfUpdateIo } from './self-update.js';
+/**
+ * Runs the update with stop handlers installed for exactly its duration. A
+ * stop interrupts it: the running child gets the same signal and the stop cap
+ * to exit, the command says what is installed now, then ends by that signal.
+ */
+export declare function runSelfUpdate(io: SelfUpdateIo, install: GlobalInstall): Promise<number>;
+//# sourceMappingURL=self-update-command.d.ts.map

package/dist/self-update-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"self-update-command.d.ts","sourceRoot":"","sources":["../src/self-update-command.ts"],"names":[],"mappings":"AAYA,OAAO,EAQL,KAAK,aAAa,EAClB,KAAK,YAAY,EAClB,MAAM,kBAAkB,CAAA;AAyWzB;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,EAAE,EAAE,YAAY,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CA8B7F"}