oh-my-opencode 5.1.29 → 5.1.32

package/dist/cli/install-command-options.d.ts

@@ -0,0 +1,20 @@
+import type { InstallArgs } from "./types";
+export type InstallCommandOptions = {
+    readonly tui?: boolean;
+    readonly claude?: InstallArgs["claude"];
+    readonly openai?: InstallArgs["openai"];
+    readonly gemini?: InstallArgs["gemini"];
+    readonly copilot?: InstallArgs["copilot"];
+    readonly platform?: InstallArgs["platform"];
+    readonly opencodeZen?: InstallArgs["opencodeZen"];
+    readonly zaiCodingPlan?: InstallArgs["zaiCodingPlan"];
+    readonly kimiForCoding?: InstallArgs["kimiForCoding"];
+    readonly opencodeGo?: InstallArgs["opencodeGo"];
+    readonly bailianCodingPlan?: InstallArgs["bailianCodingPlan"];
+    readonly minimaxCnCodingPlan?: InstallArgs["minimaxCnCodingPlan"];
+    readonly minimaxCodingPlan?: InstallArgs["minimaxCodingPlan"];
+    readonly vercelAiGateway?: InstallArgs["vercelAiGateway"];
+    readonly codexAutonomous?: InstallArgs["codexAutonomous"];
+    readonly skipAuth?: boolean;
+};
+export declare function resolveInstallArgs(options: InstallCommandOptions, invocationName?: string | undefined): InstallArgs;

package/dist/cli/service-auth/browser.d.ts

@@ -0,0 +1,3 @@
+type BrowserExec = (file: string, args: readonly string[], env: NodeJS.ProcessEnv) => Promise<boolean>;
+export declare function openSignInBrowser(url: string, executeBrowser?: BrowserExec, platform?: NodeJS.Platform, environment?: NodeJS.ProcessEnv): Promise<boolean>;
+export {};

package/dist/cli/service-auth/cli-keystore.fixture.d.ts

@@ -0,0 +1,7 @@
+declare const fakeStoreUrl: string | undefined;
+declare const get: () => Promise<string | null>;
+declare const set: ({ value }: {
+    readonly value: string;
+}) => Promise<void>;
+declare const remove: () => Promise<boolean>;
+declare const failure: string | undefined;

package/dist/cli/service-auth/commands.d.ts

@@ -0,0 +1,19 @@
+import { Command } from "commander";
+import { type ListedDevice } from "./protocol";
+type Options = {
+    readonly api?: string;
+    readonly accounts?: string;
+    readonly device?: boolean;
+    readonly browser?: boolean;
+};
+export declare function deviceChoices(devices: readonly ListedDevice[]): {
+    value: string;
+    label: string;
+}[];
+/** The OmO sign-in page. `accounts.omo.dev` is the identity provider's own account portal (#9965). */
+export declare const DEFAULT_ACCOUNTS_ORIGIN = "https://signin.omo.dev";
+/** The sign-in origin: the `--accounts` flag, then `OMO_SERVICE_ACCOUNTS_URL`, then the default. */
+export declare function accountsOrigin(options: Pick<Options, "accounts">, env: Record<string, string | undefined>): string;
+export declare function configureServiceAuthCommands(program: Command): void;
+export declare function runServiceAuthCommand(args: readonly string[]): Promise<void>;
+export {};

package/dist/cli/service-auth/device-flow.d.ts

@@ -0,0 +1,15 @@
+import { type ChooseDevice, type Platform } from "./protocol";
+import type { Session } from "./session";
+export type DisplayCode = {
+    readonly verificationUri: string;
+    readonly userCode: string;
+    readonly matchingCode: string;
+};
+export declare function loginDevice(session: Session, options: {
+    readonly name: string;
+    readonly platform: Platform;
+    readonly show: (code: DisplayCode) => void;
+    readonly chooseDevice: ChooseDevice;
+    readonly now?: () => number;
+    readonly sleep?: (ms: number) => Promise<void>;
+}): Promise<void>;

package/dist/cli/service-auth/device-keys.d.ts

@@ -0,0 +1,10 @@
+export declare function generateDeviceKeys(): {
+    public: {
+        signingKey: string;
+        sealingKey: string;
+    };
+    private: {
+        signingPrivateKey: string;
+        sealingPrivateKey: string;
+    };
+};

package/dist/cli/service-auth/device-name.d.ts

@@ -0,0 +1,3 @@
+import { type Platform } from "./protocol";
+export declare function deviceName(host?: string): string;
+export declare function devicePlatform(): Platform;

package/dist/cli/service-auth/keystore.d.ts

@@ -0,0 +1,20 @@
+import { type Credentials } from "./protocol";
+type SecretKey = {
+    readonly service: string;
+    readonly name: string;
+};
+export type SecretApi = {
+    readonly get: (key: SecretKey) => Promise<string | null>;
+    readonly set: (key: SecretKey & {
+        readonly value: string;
+    }) => Promise<void>;
+    readonly delete: (key: SecretKey) => Promise<boolean>;
+};
+export type CredentialStore = {
+    readonly read: () => Promise<Credentials | null>;
+    readonly write: (value: Credentials) => Promise<void>;
+    readonly clear: () => Promise<void>;
+};
+export declare function credentialId(api: string): string;
+export declare function createCredentialStore(api: string, secrets?: SecretApi | null, platform?: NodeJS.Platform): CredentialStore;
+export {};

package/dist/cli/service-auth/loopback.d.ts

@@ -0,0 +1,11 @@
+import { type ChooseDevice, type Platform, SignInError } from "./protocol";
+import type { Session } from "./session";
+export declare class BrowserUnavailable extends SignInError {
+}
+export declare function loginLoopback(session: Session, options: {
+    readonly accounts: string;
+    readonly name: string;
+    readonly platform: Platform;
+    readonly open: (url: string) => Promise<boolean>;
+    readonly chooseDevice: ChooseDevice;
+}): Promise<void>;

package/dist/cli/service-auth/protocol.d.ts

@@ -0,0 +1,86 @@
+import { z } from "zod";
+export declare class SignInError extends Error {
+    readonly retryable: boolean;
+    readonly name = "SignInError";
+    constructor(message: string, retryable?: boolean);
+}
+export declare class RequestFailure extends SignInError {
+    readonly notSent: boolean;
+    constructor(notSent: boolean);
+}
+export declare const platformSchema: z.ZodEnum<{
+    linux: "linux";
+    macos: "macos";
+    windows: "windows";
+}>;
+export type Platform = z.infer<typeof platformSchema>;
+export declare const tokenSchema: z.ZodObject<{
+    accessToken: z.ZodString;
+    accessTokenExpiresAt: z.ZodString;
+    refreshToken: z.ZodString;
+}, z.core.$strip>;
+export declare const grantSchema: z.ZodObject<{
+    accessToken: z.ZodString;
+    accessTokenExpiresAt: z.ZodString;
+    refreshToken: z.ZodString;
+    device: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>;
+    offlineGrant: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const credentialSchema: z.ZodObject<{
+    accessToken: z.ZodString;
+    accessTokenExpiresAt: z.ZodString;
+    refreshToken: z.ZodString;
+    device: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>;
+    offlineGrant: z.ZodOptional<z.ZodString>;
+    signingPrivateKey: z.ZodString;
+    sealingPrivateKey: z.ZodString;
+    refreshState: z.ZodOptional<z.ZodLiteral<"uncertain">>;
+}, z.core.$strip>;
+export type Credentials = z.infer<typeof credentialSchema>;
+export declare const deviceCodeSchema: z.ZodObject<{
+    deviceCode: z.ZodString;
+    userCode: z.ZodString;
+    matchingCode: z.ZodString;
+    verificationUri: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>;
+    expiresAt: z.ZodString;
+    intervalSeconds: z.ZodNumber;
+}, z.core.$strip>;
+declare const limitSchema: z.ZodObject<{
+    reason: z.ZodLiteral<"device_limit">;
+    managementToken: z.ZodString;
+    used: z.ZodNumber;
+    limit: z.ZodNumber;
+}, z.core.$strip>;
+export declare const deviceListSchema: z.ZodObject<{
+    devices: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        revokedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ListedDevice = z.infer<typeof deviceListSchema>["devices"][number];
+export type ChooseDevice = (devices: readonly ListedDevice[]) => Promise<string | null>;
+export declare class ApiRefusal extends SignInError {
+    #private;
+    readonly status: number;
+    readonly code: string;
+    constructor(code: string, status: number, detail?: z.infer<typeof limitSchema>, retryAfter?: string | null);
+    get detail(): {
+        reason: "device_limit";
+        managementToken: string;
+        used: number;
+        limit: number;
+    } | undefined;
+    retryDelay(now: number, fallback: number): number;
+}
+export declare function parseReply<T>(schema: z.ZodType<T>, value: unknown): T;
+export declare function serviceOrigin(value: string): string;
+export declare function requestApi(api: string, path: string, init: RequestInit, signal?: AbortSignal): Promise<unknown>;
+export declare const jsonRequest: (body: unknown) => RequestInit;
+export {};

package/dist/cli/service-auth/refresh-child.fixture.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/service-auth/session.d.ts

@@ -0,0 +1,17 @@
+import { type CredentialStore } from "./keystore";
+import { type ChooseDevice, type Credentials } from "./protocol";
+export declare function createSession(options: {
+    readonly api: string;
+    readonly store: CredentialStore;
+    readonly home?: string;
+    readonly signal?: AbortSignal;
+}): {
+    request: (path: string, init: RequestInit) => Promise<unknown>;
+    signal: AbortSignal | undefined;
+    ready(): Promise<void>;
+    save(value: Credentials): Promise<void>;
+    logout(): Promise<boolean>;
+    accessToken(): Promise<string>;
+    removeForLimit(error: unknown, choose: ChooseDevice): Promise<boolean>;
+};
+export type Session = ReturnType<typeof createSession>;

package/dist/cli/service-auth/terminal-text.d.ts

@@ -0,0 +1 @@
+export declare function terminalText(value: string): string;

package/dist/cli/service-auth/test-support.d.ts

@@ -0,0 +1,43 @@
+import type { SecretApi } from "./keystore";
+export declare const grant: {
+    accessToken: string;
+    accessTokenExpiresAt: string;
+    refreshToken: string;
+    offlineGrant: string;
+    device: {
+        id: string;
+        name: string;
+    };
+};
+export declare const privateKeys: {
+    signingPrivateKey: string;
+    sealingPrivateKey: string;
+};
+export declare const refusal: (code: string, detail?: unknown, status?: number) => Response;
+export declare const limitDetail: {
+    reason: string;
+    managementToken: string;
+    used: number;
+    limit: number;
+};
+export declare function temporaryHome(): Promise<string>;
+export declare function fakeApi(handler: (request: Request) => Response | Promise<Response>): string;
+export declare function memorySecrets(): {
+    api: SecretApi;
+    values: Map<string, string>;
+    writes: string[];
+    store: (origin: string) => import("./keystore").CredentialStore;
+};
+export declare function clock(): {
+    now: () => number;
+    delays: number[];
+    sleep: (ms: number) => Promise<void>;
+};
+export declare const minted: {
+    deviceCode: string;
+    userCode: string;
+    matchingCode: string;
+    verificationUri: string;
+    expiresAt: string;
+    intervalSeconds: number;
+};

package/dist/cli/service-auth/tls-test-certificate.d.ts

@@ -0,0 +1,4 @@
+export declare function tlsTestCertificate(): {
+    key: string;
+    cert: string;
+};