orizu 0.5.49 → 0.5.50

package/dist/skill-installer.js

@@ -1,6 +1,6 @@
 // Reads the bundled skill (the repository copy when run from source) and the install targets it is given.
 // @tia-reads: skills/orizu
-import { cpSync, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, readlinkSync, realpathSync, renameSync, rmdirSync, rmSync, symlinkSync, unlinkSync, writeFileSync, } from 'fs';
+import { cpSync, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, readlinkSync, realpathSync, renameSync, rmdirSync, rmSync, unlinkSync, writeFileSync, } from 'fs';
 import { dirname, isAbsolute, join, relative, resolve, sep } from 'path';
 import { fileURLToPath } from 'url';
 import { homedir } from 'os';
@@ -266,7 +266,7 @@ export function resolveEffectiveInstallMode(target, sourceRoot, mode = 'auto') {
     }
     return isStableSkillSourcePath(sourceRoot) ? 'link' : 'copy';
 }
-function shouldCopySkillPath(sourceRoot, sourcePath) {
+export function shouldCopySkillPath(sourceRoot, sourcePath) {
     const rel = relative(sourceRoot, sourcePath).replace(/\\/g, '/');
     if (!rel) {
         return true;
@@ -280,14 +280,6 @@ function shouldCopySkillPath(sourceRoot, sourcePath) {
         part === '.pytest_cache' ||
         part === SKILL_META_FILENAME) && !rel.endsWith('.pyc') && !rel.endsWith('.pyo');
 }
-function copySkillTree(sourceDir, targetDir) {
-    rmSync(targetDir, { recursive: true, force: true });
-    mkdirSync(dirname(targetDir), { recursive: true });
-    cpSync(sourceDir, targetDir, {
-        recursive: true,
-        filter: sourcePath => shouldCopySkillPath(sourceDir, sourcePath),
-    });
-}
 function stripFrontmatter(markdown) {
     const match = markdown.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n/);
     if (!match) {
@@ -384,12 +376,7 @@ export function readSkillMeta(targetDir) {
         return null;
     }
 }
-function linkSkillTree(sourceDir, targetDir) {
-    rmSync(targetDir, { recursive: true, force: true });
-    mkdirSync(dirname(targetDir), { recursive: true });
-    symlinkSync(sourceDir, targetDir, 'dir');
-}
-export function installSkillTarget(target, options) {
+export async function installSkillTarget(target, options) {
     const source = resolveSkillSource();
     const targetPath = getSkillInstallPath(target, options);
     if (target === 'agents-md') {
@@ -408,18 +395,22 @@ export function installSkillTarget(target, options) {
     if (exists && !options?.overwrite) {
         throw new Error(`${targetPath} already exists. Pass --yes to replace it.`);
     }
-    if (mode === 'link') {
-        linkSkillTree(source.root, targetPath);
-    }
-    else {
-        copySkillTree(source.root, targetPath);
-        writeSkillMeta(targetPath, source, options);
-    }
+    const { runSkillFolderReplacement } = await import('./skill-install-workflow.js');
+    const { backup, warning } = await runSkillFolderReplacement({
+        sourceRoot: source.root,
+        targetPath,
+        // `section` is only AGENTS.md, handled above.
+        mode: mode === 'link' ? 'link' : 'copy',
+        backupPath: uniqueBackupPath(SKILL_NAME, target, options),
+        writeMarker: dir => writeSkillMeta(dir, source, options),
+    });
     return {
         target,
         path: targetPath,
         action: exists ? 'updated' : 'created',
         mode,
+        ...(backup ? { backup } : {}),
+        ...(warning ? { warning } : {}),
     };
 }
 function getAgentsMdStatus(targetPath, source, sourceHash) {
@@ -586,9 +577,9 @@ export function findLegacySkillInstalls(options) {
 function backupDirectoryFor(options) {
     return resolve(resolveHome(options), '.orizu', 'skill-backups');
 }
-function uniqueBackupPath(install, options) {
+function uniqueBackupPath(name, target, options) {
     const stamp = new Date().toISOString().replace(/[-:]/g, '').replace(/\.\d+Z$/, 'Z');
-    const base = join(backupDirectoryFor(options), `${LEGACY_SKILL_NAME}-${stamp}-${install.target}`);
+    const base = join(backupDirectoryFor(options), `${name}-${stamp}-${target}`);
     let candidate = base;
     for (let attempt = 2; pathEntryExists(candidate); attempt += 1) {
         candidate = `${base}-${attempt}`;
@@ -636,11 +627,11 @@ function removeLegacySkillInstall(install, options) {
         removeLink(install.path);
         return null;
     }
-    const backupPath = uniqueBackupPath(install, options);
+    const backupPath = uniqueBackupPath(LEGACY_SKILL_NAME, install.target, options);
     moveToBackup(install.path, backupPath);
     return backupPath;
 }
-function replaceOneLegacySkillInstall(install, options, heldBackReason) {
+async function replaceOneLegacySkillInstall(install, options, heldBackReason) {
     const installedPath = getSkillInstallPath(install.target, options);
     const needsInstall = !pathEntryExists(installedPath);
     const result = {
@@ -659,7 +650,7 @@ function replaceOneLegacySkillInstall(install, options, heldBackReason) {
     let didInstall = false;
     try {
         if (needsInstall) {
-            installSkillTarget(install.target, {
+            await installSkillTarget(install.target, {
                 ...options,
                 overwrite: false,
                 dryRun: false,
@@ -707,7 +698,7 @@ function heldBackReasonFor(install, installs, options) {
         && (!isSelected(other.target) || Boolean(options?.heldBack?.[other.target])));
     return blockingLink ? `${blockingLink.path} links to it and is left in place` : null;
 }
-export function replaceLegacySkillInstalls(options) {
+export async function replaceLegacySkillInstalls(options) {
     const { installs, problems } = findLegacySkillInstalls(options);
     // Remove links before folders, so no link is left pointing at a moved folder.
     const ordered = [
@@ -715,8 +706,10 @@ export function replaceLegacySkillInstalls(options) {
         ...installs.filter(install => install.kind === 'directory'),
     ];
     const reasons = new Map(ordered.map(install => [install, heldBackReasonFor(install, installs, options)]));
-    return {
-        replacements: ordered.map(install => replaceOneLegacySkillInstall(install, options, reasons.get(install) ?? null)),
-        problems,
-    };
+    // One at a time, in order: links go before the folders they point to.
+    const replacements = [];
+    for (const install of ordered) {
+        replacements.push(await replaceOneLegacySkillInstall(install, options, reasons.get(install) ?? null));
+    }
+    return { replacements, problems };
 }

package/dist/stored-session-requests.d.ts

@@ -0,0 +1,27 @@
+import { ServerCredentials } from './types.js';
+export interface StoredRequestOptions {
+    baseUrl: string;
+    credentials: ServerCredentials;
+    allowRefresh: boolean;
+    /** Messages when another login replaced the stored one, before the first request and before the replay. */
+    changedBeforeRequest: string;
+    changedBeforeReplay: string;
+    /** Called with each refreshed login as soon as it is stored, even if the send after it fails. */
+    onRefreshed?: (credentials: ServerCredentials) => void;
+}
+/**
+ * Refresh first when the login has expired, then send. On a 401, refresh once
+ * and send once more, only if the stored login is still the one this request
+ * used. `onRequestStart` runs before each send, never for the refresh.
+ */
+export declare function storedRequest(options: StoredRequestOptions, path: string, init: RequestInit, onRequestStart?: () => void): Promise<Response>;
+export interface LogoutResult {
+    remoteError: string | null;
+    localCredentialCleared: boolean;
+}
+/**
+ * Revoke the login on the server within ORIZU_LOGOUT_TIMEOUT_MS, then remove it
+ * locally only if it is still the stored one: another login saved meanwhile is kept.
+ */
+export declare function storedLogout(baseUrl: string, credentialKey: string, credentials: ServerCredentials, callerSignal?: AbortSignal | null): Promise<LogoutResult>;
+//# sourceMappingURL=stored-session-requests.d.ts.map

package/dist/stored-session-requests.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stored-session-requests.d.ts","sourceRoot":"","sources":["../src/stored-session-requests.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,iBAAiB,EAA4B,MAAM,YAAY,CAAA;AA6MxE,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,EAAE,iBAAiB,CAAA;IAC9B,YAAY,EAAE,OAAO,CAAA;IACrB,2GAA2G;IAC3G,oBAAoB,EAAE,MAAM,CAAA;IAC5B,mBAAmB,EAAE,MAAM,CAAA;IAC3B,iGAAiG;IACjG,WAAW,CAAC,EAAE,CAAC,WAAW,EAAE,iBAAiB,KAAK,IAAI,CAAA;CACvD;AAED;;;;GAIG;AACH,wBAAsB,aAAa,CACjC,OAAO,EAAE,oBAAoB,EAC7B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,WAAW,EACjB,cAAc,CAAC,EAAE,MAAM,IAAI,GAC1B,OAAO,CAAC,QAAQ,CAAC,CAiCnB;AAED,MAAM,WAAW,YAAY;IAC3B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,sBAAsB,EAAE,OAAO,CAAA;CAChC;AAED;;;GAGG;AACH,wBAAsB,YAAY,CAChC,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,iBAAiB,EAC9B,YAAY,CAAC,EAAE,WAAW,GAAG,IAAI,GAChC,OAAO,CAAC,YAAY,CAAC,CA4BvB"}

package/dist/stored-session-requests.js

@@ -0,0 +1,264 @@
+import { Cause, Effect, Exit, Result, Schema } from 'effect';
+import { clearServerCredentialsIfCurrent, credentialsEqual, getServerCredentials, rememberResolvedBearer, updateServerCredentialsIfCurrent, withCredentialsTransactionLockAsync, } from './credentials.js';
+import { assertSecureTokenTransport, credentialRequestRedirectPolicy } from './http.js';
+import { describeLogoutHttpFailure, describeLogoutTransportFailure } from './logout-diagnostic.js';
+// Requests signed with a stored login (`orizu login`): the sign-in refresh, the
+// request and its one replay after a 401, and logout. Loaded only on that path;
+// ORIZU_TOKEN and ORIZU_TOKEN_FILE requests stay in http.ts and never load this.
+function isSessionCredentials(credentials) {
+    return 'accessToken' in credentials;
+}
+function rememberSessionCredentials(credentials) {
+    rememberResolvedBearer(credentials.accessToken);
+    rememberResolvedBearer(credentials.refreshToken);
+    return credentials;
+}
+function getAuthorizationToken(credentials) {
+    return isSessionCredentials(credentials)
+        ? rememberSessionCredentials(credentials).accessToken
+        : rememberResolvedBearer(credentials.apiKey);
+}
+function isExpired(expiresAt) {
+    const nowUnix = Math.floor(Date.now() / 1000);
+    return expiresAt <= nowUnix + 30;
+}
+function boundedTimeoutMs(name, fallback, maximum) {
+    const configured = Number(process.env[name]);
+    if (!Number.isSafeInteger(configured) || configured <= 0)
+        return fallback;
+    return Math.min(configured, maximum);
+}
+const isRedirectRefusal = (error) => error instanceof TypeError
+    && error.cause instanceof Error && /redirect/i.test(error.cause.message);
+/** fetch under the CLI's redirect policy, saying so when that policy refused a redirect. */
+async function credentialFetch(baseUrl, path, init) {
+    const policy = credentialRequestRedirectPolicy();
+    try {
+        return await fetch(`${baseUrl}${path}`, { ...init, ...policy });
+    }
+    catch (error) {
+        if (policy.redirect === 'error' && isRedirectRefusal(error)) {
+            throw new Error(`Refusing to follow a redirect from ${baseUrl} with CLI credentials.`, { cause: error });
+        }
+        throw error;
+    }
+}
+/**
+ * Runs `program`, stopped by the caller's signal or `stop`. A stop by either
+ * rejects with that signal's reason, as an aborted fetch would.
+ */
+async function runStoppable(program, ...signals) {
+    const present = signals.filter((signal) => Boolean(signal));
+    const exit = await Effect.runPromiseExit(program, { signal: AbortSignal.any(present) });
+    if (Exit.isSuccess(exit))
+        return exit.value;
+    const stoppedBy = present.find(signal => signal.aborted);
+    if (stoppedBy && Cause.hasInterruptsOnly(exit.cause))
+        throw stoppedBy.reason;
+    throw Cause.squash(exit.cause);
+}
+const RefreshReply = Schema.Struct({
+    accessToken: Schema.NonEmptyString,
+    refreshToken: Schema.NonEmptyString,
+    expiresAt: Schema.Finite,
+});
+const INVALID_REFRESH = 'Server returned invalid refresh credentials. Run `orizu login` again.';
+function refreshRequest(baseUrl, credentials) {
+    const timeoutMs = boundedTimeoutMs('ORIZU_CREDENTIALS_REFRESH_TIMEOUT_MS', 10_000, 30_000);
+    const refreshToken = rememberResolvedBearer(credentials.refreshToken);
+    return Effect.tryPromise({
+        try: async (signal) => {
+            const response = await credentialFetch(baseUrl, '/api/cli/auth/refresh', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ refreshToken }),
+                signal,
+            });
+            if (!response.ok)
+                throw new Error('Session expired. Run `orizu login` again.');
+            // Reading the body stays under the deadline too.
+            try {
+                return await response.json();
+            }
+            catch (error) {
+                throw error instanceof SyntaxError ? new Error(INVALID_REFRESH) : error;
+            }
+        },
+        catch: cause => cause instanceof Error ? cause : new Error(String(cause)),
+    }).pipe(Effect.timeoutOrElse({
+        duration: timeoutMs,
+        orElse: () => Effect.fail(new Error(`ORIZU_CREDENTIALS_REFRESH_TIMEOUT: session refresh exceeded ${timeoutMs}ms.`)),
+    }), Effect.flatMap(data => {
+        const decoded = Schema.decodeUnknownResult(RefreshReply)(data);
+        if (Result.isFailure(decoded) || decoded.success.expiresAt === 0)
+            return Effect.fail(new Error(INVALID_REFRESH));
+        const refreshed = rememberSessionCredentials({ credentialType: 'session', ...decoded.success });
+        if (isExpired(refreshed.expiresAt)) {
+            return Effect.fail(new Error('ORIZU_CREDENTIALS_REFRESH_UNUSABLE: refreshed session expires within the 30-second safety window.'));
+        }
+        return Effect.succeed(refreshed);
+    }));
+}
+const LOCK_STOP_SIGNALS = ['SIGINT', 'SIGTERM'];
+/**
+ * Stop handling for the time the credentials lock is held across a refresh.
+ * Without it a Ctrl-C ends the CLI with credentials.json.lock left behind, and
+ * every later refresh and logout fails until someone deletes it by hand. The
+ * handlers are added before the lock is taken and removed after it is
+ * released, so no stop lands between the two. A stop aborts the refresh; the
+ * lock is released as it unwinds; then the CLI ends by the same signal, unless
+ * the caller's own request was cancelled by it: then the command that owns the
+ * stop (run-gepa, a download) reports and ends the CLI itself. Other listeners
+ * don't count as owners: the git step's listener steps aside whenever another
+ * one is present.
+ */
+function lockStopWindow(callerSignal) {
+    const controller = new AbortController();
+    let stoppedBy = null;
+    const handlers = LOCK_STOP_SIGNALS.map(signal => ({
+        signal,
+        handle: () => {
+            if (stoppedBy)
+                return;
+            stoppedBy = signal;
+            controller.abort(new Error(`Session refresh stopped by ${signal}.`));
+        },
+    }));
+    return {
+        signal: controller.signal,
+        listen() { for (const entry of handlers)
+            process.on(entry.signal, entry.handle); },
+        unlisten() { for (const entry of handlers)
+            process.off(entry.signal, entry.handle); },
+        /**
+         * After the lock is released and the handlers are gone: end by the stop
+         * signal, if there was one. With no listener left the signal ends the CLI
+         * at once; a remaining listener gets it when the event loop next polls,
+         * which a second check phase is always after. If the CLI is still running
+         * then, a listener owns the stop
+         * (run-gepa may not have cancelled the request yet), and the refresh fails
+         * with the stop as its reason so the command can unwind and end itself.
+         */
+        async endIfStopped() {
+            if (!stoppedBy || callerSignal?.aborted)
+                return;
+            process.kill(process.pid, stoppedBy);
+            for (let turn = 0; turn < 2; turn += 1)
+                await new Promise(resolve => setImmediate(resolve));
+        },
+    };
+}
+async function refreshStoredCredentialsIfCurrent(baseUrl, expected, callerSignal) {
+    if (!isSessionCredentials(expected)) {
+        throw new Error('API key credentials do not refresh. Run `orizu login` again if access fails.');
+    }
+    assertSecureTokenTransport(baseUrl);
+    const stop = lockStopWindow(callerSignal);
+    stop.listen();
+    try {
+        return await withCredentialsTransactionLockAsync(async () => {
+            const current = getServerCredentials(baseUrl);
+            if (!current || !credentialsEqual(current, expected)) {
+                return { status: 'changed', credentials: current };
+            }
+            const refreshed = await runStoppable(refreshRequest(baseUrl, expected), callerSignal, stop.signal);
+            // Written inside the lock's own async context, never from the Effect fiber.
+            if (!updateServerCredentialsIfCurrent(baseUrl, expected, refreshed)) {
+                return { status: 'changed', credentials: getServerCredentials(baseUrl) };
+            }
+            return { status: 'refreshed', credentials: refreshed };
+        });
+    }
+    finally {
+        stop.unlisten();
+        await stop.endIfStopped();
+    }
+}
+function requireCurrentCredentials(baseUrl, credentials) {
+    if (credentials)
+        return credentials;
+    throw new Error(`Not logged in for ${baseUrl}. Run \`orizu login --server ${baseUrl}\` (or \`--local\`) first.`);
+}
+/**
+ * Marks an error raised after the server answered 401 and before the request
+ * was sent again: the server refused the request, so nothing was written
+ * (ORI-2431). The message is unchanged.
+ */
+function markRequestRejected(error) {
+    if (error instanceof Error && Object.isExtensible(error))
+        Object.assign(error, { requestRejected: true });
+    return error;
+}
+/**
+ * Refresh first when the login has expired, then send. On a 401, refresh once
+ * and send once more, only if the stored login is still the one this request
+ * used. `onRequestStart` runs before each send, never for the refresh.
+ */
+export async function storedRequest(options, path, init, onRequestStart) {
+    const { baseUrl } = options;
+    let credentials = options.credentials;
+    const refresh = async (changedMessage) => {
+        const result = await refreshStoredCredentialsIfCurrent(baseUrl, credentials, init.signal);
+        if (result.status === 'changed')
+            throw new Error(changedMessage);
+        credentials = requireCurrentCredentials(baseUrl, result.credentials);
+        options.onRefreshed?.(credentials);
+    };
+    const send = () => {
+        onRequestStart?.();
+        return credentialFetch(baseUrl, path, {
+            ...init,
+            headers: { ...(init.headers || {}), Authorization: `Bearer ${getAuthorizationToken(credentials)}` },
+        });
+    };
+    let didRefresh = false;
+    if (options.allowRefresh && isSessionCredentials(credentials) && isExpired(credentials.expiresAt)) {
+        await refresh(options.changedBeforeRequest);
+        didRefresh = true;
+    }
+    let response = await send();
+    if (options.allowRefresh && response.status === 401 && isSessionCredentials(credentials) && !didRefresh) {
+        try {
+            await refresh(options.changedBeforeReplay);
+        }
+        catch (error) {
+            // A stop by the caller's own signal is the caller's to describe.
+            throw error === init.signal?.reason ? error : markRequestRejected(error);
+        }
+        response = await send();
+    }
+    return response;
+}
+/**
+ * Revoke the login on the server within ORIZU_LOGOUT_TIMEOUT_MS, then remove it
+ * locally only if it is still the stored one: another login saved meanwhile is kept.
+ */
+export async function storedLogout(baseUrl, credentialKey, credentials, callerSignal) {
+    const authorizationToken = getAuthorizationToken(credentials);
+    const refreshToken = isSessionCredentials(credentials) ? rememberResolvedBearer(credentials.refreshToken) : null;
+    const secrets = [authorizationToken, ...(refreshToken !== null ? [refreshToken] : [])];
+    const timeoutMs = boundedTimeoutMs('ORIZU_LOGOUT_TIMEOUT_MS', 10_000, 30_000);
+    const timeoutError = Object.assign(new Error(`ORIZU_LOGOUT_TIMEOUT: remote logout exceeded ${timeoutMs}ms.`), { name: 'TimeoutError' });
+    const remote = Effect.tryPromise({
+        try: async (signal) => {
+            assertSecureTokenTransport(baseUrl);
+            const response = await credentialFetch(baseUrl, '/api/cli/auth/logout', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${authorizationToken}` },
+                body: refreshToken !== null ? JSON.stringify({ refreshToken }) : undefined,
+                signal,
+            });
+            return response.ok ? null : await describeLogoutHttpFailure(response, secrets);
+        },
+        catch: error => error,
+    }).pipe(Effect.timeoutOrElse({ duration: timeoutMs, orElse: () => Effect.fail(timeoutError) }));
+    let remoteError;
+    try {
+        remoteError = await runStoppable(remote, callerSignal);
+    }
+    catch (error) {
+        remoteError = describeLogoutTransportFailure(error, secrets);
+    }
+    const localCredentialCleared = clearServerCredentialsIfCurrent(credentialKey, credentials);
+    return { remoteError, localCredentialCleared };
+}

package/dist/terminal-key-session.d.ts

@@ -0,0 +1,23 @@
+export interface KeypressInfo {
+    name?: string;
+    sequence?: string;
+    ctrl?: boolean;
+}
+/** What a key does: nothing yet, finish with a value, or cancel setup. */
+export type KeyOutcome<T> = {
+    kind: 'wait';
+} | {
+    kind: 'done';
+    value: T;
+} | {
+    kind: 'cancel';
+};
+/**
+ * Hands each key to `onKey` until it finishes or cancels. A SIGINT or SIGTERM
+ * from outside ends the wait, puts the terminal back, then ends the process
+ * by that same signal.
+ */
+export declare function readKeys<T>(onKey: (key: KeypressInfo) => KeyOutcome<T>, options: {
+    hideCursor: boolean;
+}): Promise<T>;
+//# sourceMappingURL=terminal-key-session.d.ts.map

package/dist/terminal-key-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal-key-session.d.ts","sourceRoot":"","sources":["../src/terminal-key-session.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,IAAI,CAAC,EAAE,OAAO,CAAA;CACf;AAED,0EAA0E;AAC1E,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAA;AA2C9F;;;;GAIG;AACH,wBAAsB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,EAAE,YAAY,KAAK,UAAU,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE;IAAE,UAAU,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAAC,CAAC,CAAC,CAe3H"}

package/dist/terminal-key-session.js

@@ -0,0 +1,74 @@
+// Reads keys from the person's terminal for setup's pickers. Loaded only
+// through `await import(...)`, so commands without a picker never load Effect.
+import { emitKeypressEvents } from 'readline';
+import { stdin as input, stdout as output } from 'process';
+import { Effect } from 'effect';
+// The terminal goes into raw mode (keys arrive one by one, nothing is echoed)
+// and, for pickers, the cursor is hidden. The release always undoes both.
+const rawKeys = (hideCursor) => Effect.acquireRelease(Effect.sync(() => {
+    const rawInput = input;
+    const wasRaw = Boolean(rawInput.isRaw);
+    emitKeypressEvents(input);
+    if (hideCursor)
+        output.write('\x1b[?25l');
+    input.resume();
+    rawInput.setRawMode?.(true);
+    return wasRaw;
+}), wasRaw => Effect.sync(() => {
+    const rawInput = input;
+    if (rawInput.setRawMode && !wasRaw)
+        rawInput.setRawMode(false);
+    input.pause();
+    if (hideCursor)
+        output.write('\x1b[?25h');
+}));
+const nextOutcome = (onKey) => Effect.acquireUseRelease(Effect.sync(() => ({ listener: null })), held => Effect.callback(resume => {
+    held.listener = (_chunk, key) => {
+        // Ctrl-C arrives as a key in raw mode, so every picker cancels on it.
+        const outcome = key.ctrl && key.name === 'c' ? { kind: 'cancel' } : onKey(key);
+        if (outcome.kind === 'done')
+            resume(Effect.succeed(outcome.value));
+        else if (outcome.kind === 'cancel')
+            resume(Effect.fail(new Error('Setup cancelled.')));
+    };
+    input.on('keypress', held.listener);
+}), held => Effect.sync(() => { if (held.listener)
+    input.off('keypress', held.listener); }));
+const STOP_SIGNALS = ['SIGINT', 'SIGTERM'];
+/**
+ * Hands each key to `onKey` until it finishes or cancels. A SIGINT or SIGTERM
+ * from outside ends the wait, puts the terminal back, then ends the process
+ * by that same signal.
+ */
+export async function readKeys(onKey, options) {
+    const controller = new AbortController();
+    const stop = { by: null };
+    const handlers = STOP_SIGNALS.map(signal => [signal, () => { stop.by = signal; controller.abort(); }]);
+    for (const [signal, handler] of handlers)
+        process.once(signal, handler);
+    try {
+        const value = await Effect.runPromise(Effect.scoped(Effect.andThen(rawKeys(options.hideCursor), nextOutcome(onKey))), { signal: controller.signal });
+        if (stop.by)
+            return await endBy(stop.by, handlers);
+        return value;
+    }
+    catch (error) {
+        if (!stop.by)
+            throw error;
+        return await endBy(stop.by, handlers);
+    }
+    finally {
+        for (const [signal, handler] of handlers)
+            process.removeListener(signal, handler);
+    }
+}
+/** Ends the process by the signal that stopped it, once its handlers are gone. */
+async function endBy(signal, handlers) {
+    for (const [name, handler] of handlers)
+        process.removeListener(name, handler);
+    output.write('\n');
+    process.kill(process.pid, signal);
+    // The signal ends the process; if another listener holds it, exit as a shell would.
+    setTimeout(() => process.exit(signal === 'SIGINT' ? 130 : 143), 1_000);
+    return await new Promise(() => { });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orizu",
-  "version": "0.5.49",
+  "version": "0.5.50",
   "private": false,
   "type": "module",
   "main": "./dist/index.js",

package/src/account-directory.ts

@@ -5,6 +5,7 @@ import { createInterface } from 'readline/promises'
 import { isInteractiveTerminal, normalizeSlugInput, hasJsonFlag, getArg } from './command-line-arguments.js'
 import { printLine, printError, printJson } from './cli-console-output.js'
 import { sanitizeTerminalText, parseJsonResponse } from './json-response.js'
+import { PROJECT_LIST, readDirectoryList, TEAM_LIST } from './directory-list-read.js'
 import { type AuthenticatedRequestContext, authedFetch } from './http.js'
 
 interface Team {
@@ -168,27 +169,18 @@ async function promptSelect<T>(
 }
 
 type AuthenticatedRequest = AuthenticatedRequestContext['fetch']
-async function fetchTeams(request: AuthenticatedRequest = authedFetch): Promise<Team[]> {
-  const response = await request('/api/cli/teams')
-  if (!response.ok) {
-    throw new Error(`Failed to fetch teams: ${await response.text()}`)
-  }
-  const data = await parseJsonResponse<{ teams: Team[] }>(response, 'Teams list')
-  return data.teams
+async function fetchTeams(request: AuthenticatedRequest = authedFetch, timeoutMs?: number): Promise<Team[]> {
+  return await readDirectoryList(request, '/api/cli/teams', TEAM_LIST, timeoutMs)
 }
 
 async function fetchProjects(
   teamSlug?: string,
-  request: AuthenticatedRequest = authedFetch
+  request: AuthenticatedRequest = authedFetch,
+  timeoutMs?: number
 ): Promise<Project[]> {
   const normalizedTeamSlug = teamSlug ? normalizeSlugInput(teamSlug) : undefined
   const query = normalizedTeamSlug ? `?teamSlug=${encodeURIComponent(normalizedTeamSlug)}` : ''
-  const response = await request(`/api/cli/projects${query}`)
-  if (!response.ok) {
-    throw new Error(`Failed to fetch projects: ${await response.text()}`)
-  }
-  const data = await parseJsonResponse<{ projects: Project[] }>(response, 'Projects list')
-  return data.projects
+  return await readDirectoryList(request, `/api/cli/projects${query}`, PROJECT_LIST, timeoutMs)
 }
 
 async function fetchTasks(project?: string, status = 'active'): Promise<Task[]> {
@@ -252,34 +244,8 @@ async function createProjectOnServer(
   name: string,
   request: AuthenticatedRequest = authedFetch
 ): Promise<Project> {
-  const response = await request('/api/cli/projects', {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ teamSlug, name }),
-  })
-  if (!response.ok) {
-    throw new Error(`Failed to create project: ${await response.text()}`)
-  }
-  const data = await parseJsonResponse<{
-    project: {
-      id: string
-      name: string
-      slug: string
-      teamId?: string
-      teamName?: string
-      teamSlug: string
-      role?: string
-    }
-  }>(response, 'Project create')
-  return {
-    id: data.project.id,
-    name: data.project.name,
-    slug: data.project.slug,
-    teamId: data.project.teamId || '',
-    teamName: data.project.teamName || data.project.teamSlug,
-    teamSlug: data.project.teamSlug,
-    role: data.project.role || 'admin',
-  }
+  const { createProjectWithDeadline } = await import('./project-create-workflow.js')
+  return await createProjectWithDeadline(teamSlug, name, request)
 }
 
 async function resolveProjectSelection(projectArg: string | null): Promise<Project> {