@asteroidai/cli 1.9.12 → 1.9.28

package/src/auth/workos.ts

@@ -1,171 +0,0 @@
-export interface DeviceAuthorization {
-  device_code: string;
-  user_code: string;
-  verification_uri: string;
-  verification_uri_complete?: string;
-  expires_in: number;
-  interval: number;
-}
-
-export interface WorkosOrg {
-  id: string;
-  name: string;
-}
-
-export interface Session {
-  accessToken: string;
-  refreshToken: string;
-  organizationId?: string;
-  email?: string;
-}
-
-export class WorkosError extends Error {
-  constructor(
-    readonly code: string,
-    message: string,
-    readonly body: Record<string, unknown> = {},
-  ) {
-    super(message);
-  }
-}
-
-export interface WorkosClient {
-  clientId: string;
-  apiUrl: string;
-  fetch?: typeof fetch;
-  sleep?: (ms: number) => Promise<void>;
-}
-
-const AUTHENTICATE = "/user_management/authenticate";
-const TIMEOUT_MS = 15_000;
-
-async function post(
-  client: WorkosClient,
-  path: string,
-  body: Record<string, string>,
-): Promise<Record<string, unknown>> {
-  const response = await (client.fetch ?? fetch)(`${client.apiUrl}${path}`, {
-    method: "POST",
-    headers: { Accept: "application/json" },
-    body: new URLSearchParams({ client_id: client.clientId, ...body }),
-    signal: AbortSignal.timeout(TIMEOUT_MS),
-  });
-  const json = (await response.json().catch(() => ({}))) as Record<
-    string,
-    unknown
-  >;
-  if (!response.ok) {
-    const code = String(json.error ?? json.code ?? response.status);
-    const message = String(json.error_description ?? json.message ?? code);
-    throw new WorkosError(code, message, json);
-  }
-  return json;
-}
-
-function pollOnce(client: WorkosClient, deviceCode: string) {
-  return post(client, AUTHENTICATE, {
-    grant_type: "urn:ietf:params:oauth:grant-type:device_code",
-    device_code: deviceCode,
-  });
-}
-
-function selectOrg(
-  client: WorkosClient,
-  pendingAuthenticationToken: string,
-  organizationId: string,
-) {
-  return post(client, AUTHENTICATE, {
-    grant_type: "urn:workos:oauth:grant-type:organization-selection",
-    pending_authentication_token: pendingAuthenticationToken,
-    organization_id: organizationId,
-  });
-}
-
-function session(json: Record<string, unknown>): Session {
-  const user = json.user as { email?: string } | undefined;
-  return {
-    accessToken: String(json.access_token),
-    refreshToken: String(json.refresh_token),
-    organizationId: (json.organization_id as string | undefined) ?? undefined,
-    email: user?.email,
-  };
-}
-
-export async function authorizeDevice(
-  client: WorkosClient,
-): Promise<DeviceAuthorization> {
-  return (await post(
-    client,
-    "/user_management/authorize/device",
-    {},
-  )) as unknown as DeviceAuthorization;
-}
-
-export async function pollDevice(
-  client: WorkosClient,
-  device: DeviceAuthorization,
-  chooseOrg: (orgs: WorkosOrg[]) => Promise<WorkosOrg>,
-): Promise<Session> {
-  const sleep = client.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
-  let interval = (device.interval || 5) * 1000;
-  const deadline = Date.now() + device.expires_in * 1000;
-  while (Date.now() < deadline) {
-    await sleep(interval);
-    try {
-      return session(await pollOnce(client, device.device_code));
-    } catch (error) {
-      if (!(error instanceof WorkosError)) throw error;
-      if (error.code === "authorization_pending") continue;
-      if (error.code === "slow_down") {
-        interval += 5000;
-        continue;
-      }
-      if (error.code === "organization_selection_required") {
-        const orgs =
-          (error.body.organizations as WorkosOrg[] | undefined) ?? [];
-        const org = await chooseOrg(orgs);
-        return session(
-          await selectOrg(
-            client,
-            String(error.body.pending_authentication_token),
-            org.id,
-          ),
-        );
-      }
-      throw error;
-    }
-  }
-  throw new WorkosError(
-    "expired_token",
-    "the sign-in code expired; run asteroid login again",
-  );
-}
-
-export async function refresh(
-  client: WorkosClient,
-  refreshToken: string,
-  organizationId?: string,
-): Promise<Session> {
-  return session(
-    await post(client, AUTHENTICATE, {
-      grant_type: "refresh_token",
-      refresh_token: refreshToken,
-      ...(organizationId ? { organization_id: organizationId } : {}),
-    }),
-  );
-}
-
-export interface Claims {
-  exp?: number;
-  org_id?: string;
-  org?: { id?: string; name?: string };
-}
-
-export function tokenClaims(token: string): Claims {
-  try {
-    const payload = token.split(".")[1];
-    return JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
-  } catch {
-    return {};
-  }
-}

package/src/commands.ts

@@ -1,13 +0,0 @@
-import { COMMANDS } from "./generated/commands";
-import { SYNC_COMMANDS } from "./sync/commands";
-import type { CliCommand } from "./types";
-
-export function withSyncCommands(
-  commands: readonly CliCommand[],
-): CliCommand[] {
-  return [...commands, ...SYNC_COMMANDS].sort((a, b) =>
-    a.command.localeCompare(b.command),
-  );
-}
-
-export const ALL_COMMANDS = withSyncCommands(COMMANDS);

package/src/config.ts

@@ -1,125 +0,0 @@
-import envPaths from "env-paths";
-import {
-  chmodSync,
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  renameSync,
-  writeFileSync,
-} from "node:fs";
-import { dirname, join } from "node:path";
-
-import { clean } from "./output";
-
-export interface Org {
-  workosId: string;
-  id?: string;
-  name?: string;
-}
-
-export interface Config {
-  org?: Org;
-  orgs?: Org[];
-}
-
-export const DEFAULT_API_URL = "https://odyssey.asteroid.ai";
-export const DEFAULT_WORKOS_CLIENT_ID = "client_01K3NXPE8X6EJZXZSYCNT5M4P0";
-export const DEFAULT_WORKOS_API_URL = "https://api.workos.com";
-
-export interface Env {
-  apiUrl: string;
-  apiKey?: string;
-  org?: string;
-  workosClientId: string;
-  workosApiUrl: string;
-  configDir: string;
-}
-
-export function readEnv(env: NodeJS.ProcessEnv = process.env): Env {
-  return {
-    apiUrl: (env.ASTEROID_API_URL || DEFAULT_API_URL).replace(/\/+$/, ""),
-    apiKey: env.ASTEROID_API_KEY || undefined,
-    org: env.ASTEROID_ORG || undefined,
-    workosClientId: env.ASTEROID_WORKOS_CLIENT_ID || DEFAULT_WORKOS_CLIENT_ID,
-    workosApiUrl: (
-      env.ASTEROID_WORKOS_API_URL || DEFAULT_WORKOS_API_URL
-    ).replace(/\/+$/, ""),
-    configDir:
-      env.ASTEROID_CONFIG_DIR || envPaths("asteroid", { suffix: "" }).config,
-  };
-}
-
-export function readJson<T>(path: string, fallback: T): T {
-  if (!existsSync(path)) return fallback;
-  try {
-    return JSON.parse(readFileSync(path, "utf8")) as T;
-  } catch {
-    return fallback;
-  }
-}
-
-export function writePrivateJson(path: string, value: unknown) {
-  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-  const temp = `${path}.${process.pid}.tmp`;
-  writeFileSync(temp, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
-  chmodSync(temp, 0o600);
-  renameSync(temp, path);
-}
-
-export function loadConfig(env: Env): Config {
-  return readJson<Config>(join(env.configDir, "config.json"), {});
-}
-
-export function saveConfig(env: Env, config: Config) {
-  writePrivateJson(join(env.configDir, "config.json"), config);
-}
-
-export function repoOrg(cwd: string): string | undefined {
-  let dir = cwd;
-  for (;;) {
-    const file = join(dir, ".asteroid", "org");
-    if (existsSync(file)) return readFileSync(file, "utf8").trim() || undefined;
-    const parent = dirname(dir);
-    if (parent === dir) return undefined;
-    dir = parent;
-  }
-}
-
-export function requestedOrg(
-  flag: string | undefined,
-  env: Env,
-  cwd: string,
-  config: Config,
-) {
-  return flag ?? env.org ?? repoOrg(cwd) ?? config.org?.workosId;
-}
-
-export function findOrg(ref: string, orgs: Org[]): Org | undefined {
-  const lower = ref.toLowerCase();
-  return (
-    orgs.find(
-      (org) =>
-        org.workosId.toLowerCase() === lower || org.id?.toLowerCase() === lower,
-    ) ??
-    orgs.find((org) => org.name?.toLowerCase() === lower) ??
-    (/^org_[0-9a-z]+$/i.test(ref) ? { workosId: ref } : undefined)
-  );
-}
-
-export function mergeOrgs(known: Org[] = [], found: Org[] = []): Org[] {
-  const byId = new Map(known.map((org) => [org.workosId, org]));
-  for (const org of found) {
-    const merged = { ...byId.get(org.workosId) };
-    for (const [key, value] of Object.entries(org))
-      if (value !== undefined) Object.assign(merged, { [key]: value });
-    byId.set(org.workosId, merged as Org);
-  }
-  return [...byId.values()].sort((a, b) =>
-    (a.name ?? a.workosId).localeCompare(b.name ?? b.workosId),
-  );
-}
-
-export function orgLabel(org: Org): string {
-  const id = clean(org.id ?? org.workosId);
-  return org.name ? `${clean(org.name)} (${id})` : id;
-}

package/src/core.ts

@@ -1,41 +0,0 @@
-export { leadingWords, matchCommand, type Parsed, UsageError } from "./args";
-export { COMMANDS } from "./generated/commands";
-export { render } from "./output";
-export {
-  type Invocation,
-  parseInvocation,
-  type ProgramOptions,
-} from "./program";
-export { type BuiltRequest, buildRequest, type InputReader } from "./request";
-export type { CliCommand, Option } from "./types";
-export { ALL_COMMANDS, withSyncCommands } from "./commands";
-export { type Activity, formatActivitiesMarkdown } from "./sync/activities";
-export {
-  type Execution,
-  type ExecutionPullOptions,
-  type ExecutionPullResult,
-  formatExecutionPull,
-  pullExecution,
-} from "./sync/execution-pull";
-export { matchesGlob } from "./sync/paths";
-export { runSync, type SyncDeps, SYNC_COMMANDS } from "./sync/run";
-export {
-  type FileEntry,
-  type FileTree,
-  type LocalFiles,
-  MANIFEST,
-  type Manifest,
-  type Remote,
-  type Sync,
-} from "./sync/types";
-export {
-  formatWorkflowPull,
-  pullWorkflow,
-  type WorkflowPullOptions,
-  type WorkflowPullResult,
-} from "./sync/workflow-pull";
-export {
-  formatWorkflowPush,
-  pushWorkflow,
-  type WorkflowPushResult,
-} from "./sync/workflow-push";