@mycadet/cli 0.12.11 → 0.13.0

package/src/lib/bundle-staging.ts

@@ -1,220 +0,0 @@
-import { randomUUID } from "crypto";
-import {
-  copyFileSync,
-  existsSync,
-  mkdirSync,
-  statSync,
-  unlinkSync,
-} from "fs";
-import { join } from "path";
-
-import type { AssistantEntry } from "./assistant-config.js";
-import { dockerResourceNames } from "./docker.js";
-import { loopbackSafeFetch } from "./loopback-fetch.js";
-import { exec } from "./step-runner.js";
-
-/** Workspace-relative directory the daemon will open for staged restores. */
-export const RESTORE_STAGING_DIRNAME = ".restore-staging";
-
-export type RestoreStagingTarget =
-  | { kind: "local"; instanceDir: string }
-  | { kind: "docker"; assistantId: string };
-
-export interface StagedBundle {
-  /** Path the daemon should receive in `{ path }`. */
-  relativePath: string;
-  cleanup: () => Promise<void>;
-}
-
-const IMPORT_POLL_INTERVAL_MS = 2_000;
-const IMPORT_POLL_TIMEOUT_MS = 60 * 60 * 1000;
-
-export function stagingTargetFromEntry(
-  entry: AssistantEntry,
-): RestoreStagingTarget | null {
-  const cloud =
-    entry.cloud || (entry.project ? "gcp" : entry.sshUser ? "custom" : "local");
-  if (cloud === "docker") {
-    return { kind: "docker", assistantId: entry.assistantId };
-  }
-  if (cloud === "local" && entry.resources?.instanceDir) {
-    return { kind: "local", instanceDir: entry.resources.instanceDir };
-  }
-  return null;
-}
-
-function localWorkspaceDir(instanceDir: string): string {
-  return join(instanceDir, "workspace");
-}
-
-export function formatBundleSizeMb(bytes: number): string {
-  return (bytes / (1024 * 1024)).toFixed(2);
-}
-
-/**
- * Copy a host `.vbundle` into the assistant workspace staging directory
- * so the daemon can stream it without a large HTTP body.
- */
-export async function stageBundleForRestore(
-  target: RestoreStagingTarget,
-  hostBundlePath: string,
-): Promise<StagedBundle> {
-  const filename = `${randomUUID()}.vbundle`;
-  const relativePath = `${RESTORE_STAGING_DIRNAME}/${filename}`;
-
-  if (target.kind === "local") {
-    const stagingDir = join(
-      localWorkspaceDir(target.instanceDir),
-      RESTORE_STAGING_DIRNAME,
-    );
-    mkdirSync(stagingDir, { recursive: true });
-    const dest = join(stagingDir, filename);
-    copyFileSync(hostBundlePath, dest);
-    return {
-      relativePath,
-      cleanup: async () => {
-        try {
-          unlinkSync(dest);
-        } catch {
-          // Best-effort: a successful import may have swapped the workspace.
-        }
-      },
-    };
-  }
-
-  const container = dockerResourceNames(target.assistantId).assistantContainer;
-  const dest = `/workspace/${relativePath}`;
-  await exec("docker", [
-    "exec",
-    container,
-    "mkdir",
-    "-p",
-    `/workspace/${RESTORE_STAGING_DIRNAME}`,
-  ]);
-  await exec("docker", ["cp", hostBundlePath, `${container}:${dest}`]);
-  return {
-    relativePath,
-    cleanup: async () => {
-      try {
-        await exec("docker", ["exec", container, "rm", "-f", dest]);
-      } catch {
-        // Best-effort: a successful import may have swapped the workspace.
-      }
-    },
-  };
-}
-
-export async function preflightStagedBundle(
-  runtimeUrl: string,
-  accessToken: string,
-  relativePath: string,
-): Promise<Response> {
-  return loopbackSafeFetch(`${runtimeUrl}/v1/migrations/import-preflight`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${accessToken}`,
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify({ path: relativePath }),
-    signal: AbortSignal.timeout(120_000),
-  });
-}
-
-/**
- * Import a staged bundle. The gateway JSON import path returns 202 and
- * requires status polling; a direct daemon response of 200 is accepted too.
- */
-export async function importStagedBundle(
-  runtimeUrl: string,
-  accessToken: string,
-  relativePath: string,
-): Promise<Response> {
-  const postImport = () =>
-    loopbackSafeFetch(`${runtimeUrl}/v1/migrations/import`, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${accessToken}`,
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({ path: relativePath }),
-      signal: AbortSignal.timeout(120_000),
-    });
-
-  const response = await postImport();
-
-  if (response.status === 202) {
-    const accepted = (await response.json()) as { job_id?: string };
-    if (!accepted.job_id) {
-      return new Response(
-        JSON.stringify({ error: "Import did not return a job_id" }),
-        { status: 502, headers: { "Content-Type": "application/json" } },
-      );
-    }
-    return pollImportJob(runtimeUrl, accessToken, accepted.job_id);
-  }
-
-  return response;
-}
-
-async function pollImportJob(
-  runtimeUrl: string,
-  accessToken: string,
-  jobId: string,
-): Promise<Response> {
-  const deadline = Date.now() + IMPORT_POLL_TIMEOUT_MS;
-  while (Date.now() < deadline) {
-    const statusResponse = await loopbackSafeFetch(
-      `${runtimeUrl}/v1/migrations/import/${jobId}/status`,
-      {
-        headers: {
-          Authorization: `Bearer ${accessToken}`,
-        },
-        signal: AbortSignal.timeout(30_000),
-      },
-    );
-    if (statusResponse.status === 404) {
-      return new Response(
-        JSON.stringify({ error: `Unknown import job: ${jobId}` }),
-        { status: 404, headers: { "Content-Type": "application/json" } },
-      );
-    }
-    if (!statusResponse.ok) {
-      return statusResponse;
-    }
-
-    const job = (await statusResponse.json()) as {
-      status?: string;
-      error?: string;
-      result?: unknown;
-    };
-    if (job.status === "complete") {
-      return new Response(JSON.stringify(job.result ?? { success: true }), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    }
-    if (job.status === "failed") {
-      return new Response(
-        JSON.stringify({
-          success: false,
-          message: job.error ?? "Import failed",
-        }),
-        { status: 500, headers: { "Content-Type": "application/json" } },
-      );
-    }
-
-    await new Promise((resolve) => setTimeout(resolve, IMPORT_POLL_INTERVAL_MS));
-  }
-
-  return new Response(
-    JSON.stringify({ error: "Import timed out after 60 minutes" }),
-    { status: 504, headers: { "Content-Type": "application/json" } },
-  );
-}
-
-export function bundleFileSizeBytes(path: string): number {
-  if (!existsSync(path)) {
-    return 0;
-  }
-  return statSync(path).size;
-}

package/src/lib/job-polling.ts

@@ -1,195 +0,0 @@
-import type { UnifiedJobStatus } from "./cloud-client.js";
-
-/**
- * Terminal status returned by {@link pollJobUntilDone}. Callers decide
- * whether to treat `failed` as a fatal error or retry logic concern.
- */
-export type TerminalJobStatus = Extract<
-  UnifiedJobStatus,
-  { status: "complete" | "failed" }
->;
-
-export interface PollJobUntilDoneOptions {
-  /** Async producer that returns the latest job status. */
-  poll: () => Promise<UnifiedJobStatus>;
-  /** Sleep between successive polls. Defaults to 2_000 ms. */
-  intervalMs?: number;
-  /** Maximum wall-clock time to wait. Defaults to 60 minutes. */
-  timeoutMs?: number;
-  /** Human-readable label used in the timeout error message (e.g. "export job"). */
-  label: string;
-  /**
-   * Maximum consecutive transient (retryable) poll errors tolerated before
-   * the last error is propagated. Transient errors (5xx / network) between
-   * successful polls reset the counter. Defaults to 5.
-   */
-  maxTransientErrors?: number;
-  /**
-   * Optional async hook invoked when `poll()` throws an error containing a
-   * `401` HTTP status. The callback is expected to refresh whatever
-   * credential the poll closure reads (e.g. re-lease a guardian token), then
-   * return. The polling loop will retry the poll after the callback resolves
-   * instead of propagating the 401.
-   *
-   * Used by long-running migrations where the cached access token may expire
-   * mid-poll. Without this hook, 4xx errors (except 429) are permanent and
-   * would abandon a migration that's still running on the server.
-   */
-  refreshOn401?: () => Promise<void>;
-  /**
-   * Maximum consecutive 401 refreshes tolerated before the last 401 is
-   * propagated. Tracked separately from {@link maxTransientErrors} because
-   * a persistent 401 after a refresh usually means the underlying credential
-   * is revoked, not a transient network issue. Defaults to 3.
-   */
-  maxAuthRefreshes?: number;
-}
-
-const DEFAULT_INTERVAL_MS = 2_000;
-// Matches the server-side runtime migration window: the GCS upload PUT and
-// the import-URL fetch in assistant/src/runtime/routes/migration-routes.ts
-// use AbortSignal.timeout(60 * 60 * 1000), so a shorter CLI poll cap would
-// abort a job that's still legitimately in progress on the server.
-const DEFAULT_TIMEOUT_MS = 60 * 60 * 1000;
-const DEFAULT_MAX_TRANSIENT_ERRORS = 5;
-const DEFAULT_MAX_AUTH_REFRESHES = 3;
-
-function is401Error(err: unknown): boolean {
-  const msg = err instanceof Error ? err.message : String(err);
-  return /\b401\b/.test(msg);
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-/**
- * Heuristic classification used by {@link pollJobUntilDone} to decide whether
- * to retry a failed poll.
- *
- * - 5xx responses and unclassifiable network-style errors (fetch failed,
- *   ECONNRESET, etc.) are treated as transient.
- * - 4xx responses are treated as permanent, except 429 (rate limited) which is
- *   transient.
- * - "not found" errors are permanent — they indicate the job id is wrong and
- *   retrying won't help.
- *
- * The poll helpers (`platformPollJobStatus`, `localRuntimePollJobStatus`)
- * raise errors whose message contains the HTTP status (e.g. `"Local job
- * status check failed: 503 Service Unavailable"`), so we parse that out when
- * available and default to "retry" when unsure.
- */
-function isTransientPollError(err: unknown): boolean {
-  const msg = err instanceof Error ? err.message : String(err);
-
-  if (msg.includes("not found")) return false;
-
-  const match = msg.match(/(?:status check failed|failed)[^\d]*(\d{3})/i);
-  if (match) {
-    const code = parseInt(match[1], 10);
-    if (code === 429) return true;
-    if (code >= 400 && code < 500) return false;
-    if (code >= 500) return true;
-  }
-
-  // Unclassifiable (e.g. "fetch failed", ECONNRESET) — treat as transient so
-  // a single network hiccup doesn't abort a long-running migration.
-  return true;
-}
-
-/**
- * Poll `options.poll` until it returns a terminal status (`complete` or
- * `failed`), or until `timeoutMs` elapses.
- *
- * On terminal status, returns the status object — including the `failed`
- * case. The caller decides how to treat a failed terminal status (e.g.
- * print the `error` field and exit). Timeouts throw.
- *
- * Transient errors raised by `poll()` (5xx, network hiccups, rate-limits) are
- * retried up to `maxTransientErrors` times before the last error propagates,
- * matching the pre-rewrite migration-export polling loop's behavior so a
- * single flaky poll doesn't abort a migration that may still be running.
- */
-export async function pollJobUntilDone(
-  options: PollJobUntilDoneOptions,
-): Promise<TerminalJobStatus> {
-  const intervalMs = options.intervalMs ?? DEFAULT_INTERVAL_MS;
-  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const maxTransientErrors =
-    options.maxTransientErrors ?? DEFAULT_MAX_TRANSIENT_ERRORS;
-  const maxAuthRefreshes =
-    options.maxAuthRefreshes ?? DEFAULT_MAX_AUTH_REFRESHES;
-  const deadline = Date.now() + timeoutMs;
-
-  let consecutiveTransientErrors = 0;
-  let consecutiveAuthRefreshes = 0;
-
-  // First poll happens immediately so fast-path completions don't wait
-  // one interval before returning.
-  while (true) {
-    let status: UnifiedJobStatus;
-    try {
-      status = await options.poll();
-      consecutiveTransientErrors = 0;
-      consecutiveAuthRefreshes = 0;
-    } catch (err) {
-      // 401 Unauthorized takes precedence over the generic transient
-      // classifier: when a refresh callback is registered, a long-running
-      // poll loop can re-lease its credential and keep going instead of
-      // abandoning a migration that's still running on the server.
-      if (options.refreshOn401 && is401Error(err)) {
-        consecutiveAuthRefreshes += 1;
-        if (consecutiveAuthRefreshes > maxAuthRefreshes) {
-          throw err;
-        }
-        const msg = err instanceof Error ? err.message : String(err);
-        console.warn(
-          `${options.label} polling got 401, refreshing auth and retrying... (${msg})`,
-        );
-        await options.refreshOn401();
-        if (Date.now() >= deadline) {
-          throw new Error(
-            `Timed out waiting for ${options.label} after ${Math.round(
-              timeoutMs / 1000,
-            )}s`,
-          );
-        }
-        await sleep(intervalMs);
-        continue;
-      }
-
-      if (!isTransientPollError(err)) {
-        throw err;
-      }
-      consecutiveTransientErrors += 1;
-      if (consecutiveTransientErrors > maxTransientErrors) {
-        throw err;
-      }
-      const msg = err instanceof Error ? err.message : String(err);
-      console.warn(`${options.label} polling failed: ${msg}. Retrying...`);
-      if (Date.now() >= deadline) {
-        throw new Error(
-          `Timed out waiting for ${options.label} after ${Math.round(
-            timeoutMs / 1000,
-          )}s`,
-        );
-      }
-      await sleep(intervalMs);
-      continue;
-    }
-
-    if (status.status === "complete" || status.status === "failed") {
-      return status;
-    }
-
-    if (Date.now() >= deadline) {
-      throw new Error(
-        `Timed out waiting for ${options.label} after ${Math.round(
-          timeoutMs / 1000,
-        )}s`,
-      );
-    }
-
-    await sleep(intervalMs);
-  }
-}