@asteroidai/cli 1.9.12 → 1.9.28

package/src/sync/types.ts

@@ -1,58 +0,0 @@
-import type { BuiltRequest } from "../request";
-
-export interface LocalFiles {
-  read(path: string): Promise<Uint8Array | undefined>;
-  write(path: string, bytes: Uint8Array): Promise<void>;
-  remove(path: string): Promise<void>;
-  list(dir: string): Promise<string[]>;
-}
-
-export interface Remote {
-  json(request: BuiltRequest): Promise<unknown>;
-  download(url: string): Promise<Uint8Array>;
-}
-
-export interface Sync {
-  remote: Remote;
-  files: LocalFiles;
-}
-
-export interface FileEntry {
-  path: string;
-  kind: string;
-  size: number;
-  content?: string;
-  contentBase64?: string;
-  checksum?: string;
-  fileId?: string;
-}
-
-export interface FileTree {
-  rev: number;
-  version?: number;
-  versionId: string;
-  workflowName: string;
-  files: FileEntry[];
-}
-
-export const MANIFEST = ".asteroid.json";
-
-export interface Manifest {
-  workflowId: string;
-  versionId: string;
-  head: boolean;
-  rev: number;
-  files: Record<string, string>;
-}
-
-export function get(
-  path: string,
-  query: Record<string, string> = {},
-): BuiltRequest {
-  return { method: "GET", path, query: new URLSearchParams(query) };
-}
-
-export function statusOf(error: unknown): number | undefined {
-  const status = (error as { status?: unknown } | null)?.status;
-  return typeof status === "number" ? status : undefined;
-}

package/src/sync/workflow-pull.ts

@@ -1,185 +0,0 @@
-import type { BuiltRequest } from "../request";
-import {
-  isContained,
-  join,
-  sha256,
-  workflowDirName,
-  workflowRoot,
-} from "./paths";
-import {
-  type FileEntry,
-  type FileTree,
-  get,
-  MANIFEST,
-  type Manifest,
-  type Sync,
-} from "./types";
-
-const CONCURRENCY = 16;
-
-export interface WorkflowPullOptions {
-  workflowId: string;
-  request: BuiltRequest;
-  dir?: string;
-  root?: string;
-  manifest?: boolean;
-  maxFileBytes?: number;
-}
-
-export interface WorkflowPullResult {
-  workflowId: string;
-  workflowName: string;
-  versionId: string;
-  version?: number;
-  rev: number;
-  dir: string;
-  head: boolean;
-  written: number;
-  shared: number;
-  skipped: string[];
-}
-
-export function pullDir(root: string, tree: FileTree, head: boolean): string {
-  const base = workflowRoot(root, tree.workflowName);
-  if (head) return join(base, "head");
-  return join(base, ".versions", workflowDirName(tree.versionId, tree.version));
-}
-
-async function agentFileBytes(
-  sync: Sync,
-  workflowId: string,
-  tree: FileTree,
-  entry: FileEntry,
-): Promise<Uint8Array> {
-  const path = `/agents/v2/workflows/${workflowId}/versions/${tree.versionId}/files/${entry.fileId}/signed-url`;
-  const { url } = (await sync.remote.json(get(path))) as { url: string };
-  return sync.remote.download(url);
-}
-
-export async function entryBytes(
-  sync: Sync,
-  workflowId: string,
-  tree: FileTree,
-  entry: FileEntry,
-): Promise<Uint8Array | undefined> {
-  if (entry.contentBase64 !== undefined)
-    return Buffer.from(entry.contentBase64, "base64");
-  if (entry.content !== undefined) return Buffer.from(entry.content, "utf8");
-  if (!entry.fileId) return undefined;
-  return agentFileBytes(sync, workflowId, tree, entry);
-}
-
-async function writeEntries(
-  sync: Sync,
-  options: WorkflowPullOptions,
-  tree: FileTree,
-  dir: string,
-) {
-  const hashes: Record<string, string> = {};
-  const skipped: string[] = [];
-  let shared = 0;
-  const wanted = tree.files.filter((entry) => {
-    if (!isContained(entry.path)) skipped.push(`${entry.path} (unsafe path)`);
-    else if (
-      options.maxFileBytes !== undefined &&
-      entry.size > options.maxFileBytes
-    )
-      skipped.push(`${entry.path} (${entry.size} bytes, over the size limit)`);
-    else return true;
-    return false;
-  });
-  for (let i = 0; i < wanted.length; i += CONCURRENCY) {
-    await Promise.all(
-      wanted.slice(i, i + CONCURRENCY).map(async (entry) => {
-        const bytes = await entryBytes(sync, options.workflowId, tree, entry);
-        if (!bytes) return void skipped.push(`${entry.path} (no content)`);
-        await sync.files.write(join(dir, entry.path), bytes);
-        hashes[entry.path] = sha256(bytes);
-        if (entry.kind === "agent_file") shared++;
-      }),
-    );
-  }
-  return { hashes, skipped, shared };
-}
-
-async function removeStale(sync: Sync, dir: string, keep: Set<string>) {
-  for (const path of await sync.files.list(dir)) {
-    if (!keep.has(path) && path !== MANIFEST)
-      await sync.files.remove(join(dir, path));
-  }
-}
-
-export async function writeManifest(
-  sync: Sync,
-  dir: string,
-  manifest: Manifest,
-) {
-  const text = `${JSON.stringify(manifest, null, 2)}\n`;
-  await sync.files.write(join(dir, MANIFEST), Buffer.from(text, "utf8"));
-}
-
-export async function pullWorkflow(
-  sync: Sync,
-  options: WorkflowPullOptions,
-): Promise<WorkflowPullResult> {
-  const request = {
-    ...options.request,
-    query: new URLSearchParams(options.request.query),
-  };
-  request.query.set("contents", "all");
-  const tree = (await sync.remote.json(request)) as FileTree;
-  const head = request.path.endsWith("/head/files");
-  const dir = options.dir ?? pullDir(options.root ?? "", tree, head);
-  const { hashes, skipped, shared } = await writeEntries(
-    sync,
-    options,
-    tree,
-    dir,
-  );
-  await removeStale(sync, dir, new Set(Object.keys(hashes)));
-  if (options.manifest !== false) {
-    await writeManifest(sync, dir, {
-      workflowId: options.workflowId,
-      versionId: tree.versionId,
-      head,
-      rev: tree.rev,
-      files: hashes,
-    });
-  }
-  return {
-    workflowId: options.workflowId,
-    workflowName: tree.workflowName,
-    versionId: tree.versionId,
-    version: tree.version,
-    rev: tree.rev,
-    dir,
-    head,
-    written: Object.keys(hashes).length,
-    shared,
-    skipped,
-  };
-}
-
-export function formatWorkflowPull(result: WorkflowPullResult): string {
-  const definition = result.written - result.shared;
-  const files =
-    result.written === 0
-      ? "Files: none written"
-      : result.shared === 0
-        ? `Files: ${result.written} written`
-        : `Files: ${result.written} written (${definition} workflow definition, ${result.shared} shared)`;
-  return [
-    `Workflow: ${result.workflowName} (${result.workflowId})`,
-    `Workflow version: ${result.versionId}${result.version ? ` (v${result.version})` : " (draft)"}`,
-    `Written to: ${result.dir}/`,
-    files,
-    result.skipped.length > 0
-      ? `Skipped:\n${result.skipped.map((s) => `  - ${s}`).join("\n")}`
-      : null,
-    result.head
-      ? `Edit the files, then run \`asteroid workflow push\` from ${result.dir}/.`
-      : "This is a pinned version. It is read-only.",
-  ]
-    .filter(Boolean)
-    .join("\n");
-}

package/src/sync/workflow-push.ts

@@ -1,161 +0,0 @@
-import { UsageError } from "../args";
-import { join, sha256 } from "./paths";
-import {
-  type FileTree,
-  get,
-  MANIFEST,
-  type Manifest,
-  statusOf,
-  type Sync,
-} from "./types";
-import { writeManifest } from "./workflow-pull";
-
-export interface WorkflowPushResult {
-  workflowId: string;
-  dir: string;
-  written: string[];
-  deleted: string[];
-  rev: number;
-  versionId: string;
-}
-
-export async function readManifest(sync: Sync, dir: string): Promise<Manifest> {
-  const bytes = await sync.files.read(join(dir, MANIFEST));
-  if (!bytes) {
-    throw new UsageError(
-      `no pulled workflow in ${dir}. Run \`asteroid workflow pull <workflow-id>\`, then push from the head folder it writes.`,
-    );
-  }
-  const manifest = JSON.parse(Buffer.from(bytes).toString("utf8")) as Manifest;
-  if (!manifest.head) {
-    throw new UsageError(
-      `${dir} holds a pinned workflow version, which is read-only. Push from a pulled head.`,
-    );
-  }
-  return manifest;
-}
-
-async function localChanges(sync: Sync, dir: string, manifest: Manifest) {
-  const local = (await sync.files.list(dir)).filter(
-    (path) => path !== MANIFEST,
-  );
-  const writes: { path: string; contentBase64: string; hash: string }[] = [];
-  for (const path of local) {
-    const bytes = await sync.files.read(join(dir, path));
-    if (!bytes) continue;
-    const hash = sha256(bytes);
-    if (manifest.files[path] === hash) continue;
-    writes.push({
-      path,
-      contentBase64: Buffer.from(bytes).toString("base64"),
-      hash,
-    });
-  }
-  const present = new Set(local);
-  const deletes = Object.keys(manifest.files).filter(
-    (path) => !present.has(path),
-  );
-  return { writes, deletes };
-}
-
-async function patch(
-  sync: Sync,
-  manifest: Manifest,
-  writes: { path: string; contentBase64: string }[],
-  deletes: string[],
-) {
-  try {
-    await sync.remote.json({
-      method: "PATCH",
-      path: `/agents/v2/workflows/${manifest.workflowId}/head/files`,
-      query: new URLSearchParams(),
-      json: { baseRev: manifest.rev, writes, deletes },
-    });
-  } catch (error) {
-    if (statusOf(error) !== 409) throw error;
-    throw new UsageError(
-      `the workflow head changed since your pull (rev ${manifest.rev}). Copy your edits aside, run \`asteroid workflow pull ${manifest.workflowId}\`, reapply them, then push again.`,
-    );
-  }
-}
-
-async function refresh(
-  sync: Sync,
-  dir: string,
-  manifest: Manifest,
-  pushed: Map<string, string>,
-) {
-  const tree = (await sync.remote.json(
-    get(`/agents/v2/workflows/${manifest.workflowId}/head/files`),
-  )) as FileTree;
-  const files: Record<string, string> = {};
-  for (const entry of tree.files) {
-    if (entry.content !== undefined) {
-      const bytes = Buffer.from(entry.content, "utf8");
-      files[entry.path] = sha256(bytes);
-      if (pushed.get(entry.path) !== files[entry.path])
-        await sync.files.write(join(dir, entry.path), bytes);
-    } else {
-      const local = await sync.files.read(join(dir, entry.path));
-      const hash = local
-        ? sha256(local)
-        : (pushed.get(entry.path) ?? entry.checksum);
-      if (hash) files[entry.path] = hash;
-    }
-  }
-  for (const path of await sync.files.list(dir)) {
-    if (path !== MANIFEST && !(path in files))
-      await sync.files.remove(join(dir, path));
-  }
-  const next = { ...manifest, versionId: tree.versionId, rev: tree.rev, files };
-  await writeManifest(sync, dir, next);
-  return next;
-}
-
-export async function pushWorkflow(
-  sync: Sync,
-  dir: string,
-  workflowId?: string,
-): Promise<WorkflowPushResult> {
-  const manifest = await readManifest(sync, dir);
-  if (workflowId !== undefined && manifest.workflowId !== workflowId) {
-    throw new UsageError(
-      `${dir} holds workflow ${manifest.workflowId}, not ${workflowId}.`,
-    );
-  }
-  const { writes, deletes } = await localChanges(sync, dir, manifest);
-  const result = {
-    workflowId: manifest.workflowId,
-    dir,
-    written: writes.map((w) => w.path),
-    deleted: deletes,
-  };
-  if (writes.length === 0 && deletes.length === 0) {
-    return { ...result, rev: manifest.rev, versionId: manifest.versionId };
-  }
-  await patch(
-    sync,
-    manifest,
-    writes.map(({ path, contentBase64 }) => ({ path, contentBase64 })),
-    deletes,
-  );
-  const next = await refresh(
-    sync,
-    dir,
-    manifest,
-    new Map(writes.map((w) => [w.path, w.hash])),
-  );
-  return { ...result, rev: next.rev, versionId: next.versionId };
-}
-
-export function formatWorkflowPush(result: WorkflowPushResult): string {
-  if (result.written.length === 0 && result.deleted.length === 0) {
-    return `Nothing to push: ${result.dir}/ matches the head you pulled (rev ${result.rev}).`;
-  }
-  return [
-    `Pushed to workflow ${result.workflowId}: ${result.written.length} written, ${result.deleted.length} deleted.`,
-    ...result.written.map((path) => `  + ${path}`),
-    ...result.deleted.map((path) => `  - ${path}`),
-    `Head is now rev ${result.rev} (version ${result.versionId}).`,
-  ].join("\n");
-}

package/src/types.ts

@@ -1,46 +0,0 @@
-export type ValueType =
-  | "string"
-  | "integer"
-  | "number"
-  | "boolean"
-  | "string[]"
-  | "integer[]"
-  | "number[]"
-  | "json";
-
-export interface Option {
-  name: string;
-  flag: string;
-  type: ValueType;
-  required: boolean;
-  description?: string;
-  enum?: string[];
-  explode?: boolean;
-  negatable?: boolean;
-}
-
-export interface BodySpec {
-  required: boolean;
-  contentType: "application/json" | "multipart/form-data";
-  fields: Option[];
-  files: string[];
-  credentialOrganization: boolean;
-}
-
-export interface CliCommand {
-  command: string;
-  tool: string;
-  title: string;
-  description: string;
-  method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
-  path: string;
-  args: Option[];
-  query: Option[];
-  body?: BodySpec;
-  binary: boolean;
-  readOnly: boolean;
-  destructive: boolean;
-  local?: boolean;
-  files?: "pull" | "push";
-  capability?: "publish" | "run_execution";
-}

package/src/ui.ts

@@ -1,30 +0,0 @@
-import * as clack from "@clack/prompts";
-
-export interface Choice {
-  value: string;
-  label: string;
-}
-
-export interface Ui {
-  select(message: string, choices: Choice[]): Promise<string | undefined>;
-  wait<T>(message: string, done: string, work: Promise<T>): Promise<T>;
-}
-
-export const clackUi: Ui = {
-  async select(message, choices) {
-    const value = await clack.select({ message, options: choices });
-    return clack.isCancel(value) ? undefined : value;
-  },
-  async wait(message, done, work) {
-    const spinner = clack.spinner();
-    spinner.start(message);
-    try {
-      const result = await work;
-      spinner.stop(done);
-      return result;
-    } catch (error) {
-      spinner.stop(message);
-      throw error;
-    }
-  },
-};