@metagptx/deepflow-cli 0.1.0

package/src/cli.js

@@ -0,0 +1,531 @@
+import { readFile } from "node:fs/promises";
+import process from "node:process";
+
+import { commandFromParsedArgs, parseArgs } from "./args.js";
+import {
+  clearAuthConfig,
+  DEFAULT_PROFILE,
+  resolveRuntimeConfig,
+  saveAuthConfig,
+} from "./config.js";
+import {
+  buildPlanStatusUrl,
+  buildSessionMessagesUrl,
+  buildSessionStopUrl,
+  DeepFlowClient,
+  DEFAULT_FAST_TIMEOUT_MS,
+  DEFAULT_TIMEOUT_MS,
+  parseTimeoutMs,
+  resolveReachableBaseUrl,
+} from "./client.js";
+import { CliError, redactToken } from "./errors.js";
+import { writeError, writeResult } from "./output.js";
+import { VERSION } from "./version.js";
+
+function buildIo() {
+  return {
+    stdout: process.stdout,
+    stderr: process.stderr,
+    stdin: process.stdin,
+  };
+}
+
+function helpText() {
+  return `DeepFlow CLI
+
+Usage:
+  deepflow -l -t <token> [--base-url <url>]
+  deepflow -login -t <token> [--base-url <url>]
+  deepflow auth login -t <token> [--base-url <url>]
+  deepflow auth logout
+  deepflow auth status [--json]
+  deepflow apps list [--json]
+  deepflow plan run --repo <repo_id_or_app_code> [--name <name>] [--context <text>] [--prompt <text>] [--json]
+  deepflow plan status --iteration <local_iteration_id> --session <session_id> [--json]
+  deepflow session messages --backend-iteration <backend_iteration_id> --session <session_id> [--json]
+  deepflow session stop --backend-iteration <backend_iteration_id> --session <session_id> [--json]
+
+Global options:
+  --base-url <url>       DeepFlow Web URL. Default: http://localhost:3100
+  -t, --token <token>    API token. Overrides config and DEEPFLOW_TOKEN.
+  --profile <name>       Config profile. Default: default
+  --json                 Machine-readable output.
+  -h, --help             Show help.
+
+Environment:
+  DEEPFLOW_BASE_URL
+  DEEPFLOW_TOKEN
+  DEEPFLOW_PROFILE
+  DEEPFLOW_CONFIG
+  DEEPFLOW_CONFIG_DIR
+`;
+}
+
+async function readStdin(io) {
+  const chunks = [];
+
+  for await (const chunk of io.stdin) {
+    chunks.push(Buffer.from(chunk));
+  }
+
+  return Buffer.concat(chunks).toString("utf8").trim();
+}
+
+async function readTextOption(flags, {
+  textName,
+  fileName,
+  fallback,
+}) {
+  if (flags[fileName]) {
+    return readFile(flags[fileName], "utf8");
+  }
+
+  return flags[textName] ?? fallback;
+}
+
+function requireToken(token) {
+  if (!token) {
+    throw new CliError("Token is required. Use -t <token> or set DEEPFLOW_TOKEN.", {
+      code: "missing_token",
+      exitCode: 3,
+    });
+  }
+
+  if (!token.startsWith("dfpat_")) {
+    throw new CliError("Token must be a DeepFlow personal API token starting with dfpat_.", {
+      code: "invalid_token_format",
+      exitCode: 2,
+    });
+  }
+}
+
+function requireOption(flags, name, message) {
+  const value = flags[name];
+
+  if (!value) {
+    throw new CliError(message, {
+      code: "missing_argument",
+      exitCode: 2,
+    });
+  }
+
+  return value;
+}
+
+function makeClient(runtimeConfig, flags) {
+  return new DeepFlowClient({
+    baseUrl: runtimeConfig.baseUrl,
+    token: runtimeConfig.token,
+    timeoutMs: parseTimeoutMs(flags.timeout, DEFAULT_TIMEOUT_MS),
+    fastTimeoutMs: parseTimeoutMs(flags.fastTimeout, DEFAULT_FAST_TIMEOUT_MS),
+  });
+}
+
+function resolveRepoIdFromIteration(iteration, repoRef) {
+  const snapshots = Array.isArray(iteration?.repoSnapshots) ? iteration.repoSnapshots : [];
+
+  if (snapshots.length === 1 && snapshots[0]?.repoId) {
+    return snapshots[0].repoId;
+  }
+
+  const matched = snapshots.find((snapshot) =>
+    [
+      snapshot.repoId,
+      snapshot.appCode,
+      snapshot.repoName,
+      snapshot.repositoryUrl,
+    ].some((value) => value && value === repoRef),
+  );
+
+  return matched?.repoId ?? repoRef;
+}
+
+function buildRepoBranches(repoRef, flags) {
+  if (!flags.baseBranch && !flags.targetBranch) {
+    return undefined;
+  }
+
+  return {
+    [repoRef]: {
+      baseBranch: flags.baseBranch ?? null,
+      targetBranch: flags.targetBranch ?? null,
+    },
+  };
+}
+
+function buildUiUrl(baseUrl, iteration, sessionId) {
+  const routeId = iteration.backendIterationId || iteration.id;
+  const path = `/iterations/${encodeURIComponent(routeId)}/plan?sessionId=${encodeURIComponent(sessionId)}`;
+
+  return new URL(path, baseUrl).toString();
+}
+
+function buildSessionLinks(baseUrl, {
+  localIterationId,
+  backendIterationId,
+  sessionId,
+}) {
+  return {
+    statusUrl: buildPlanStatusUrl(baseUrl, {
+      localIterationId,
+      sessionId,
+    }),
+    messagesUrl: buildSessionMessagesUrl(baseUrl, {
+      backendIterationId,
+      sessionId,
+    }),
+    stopUrl: buildSessionStopUrl(baseUrl, {
+      backendIterationId,
+      sessionId,
+    }),
+  };
+}
+
+async function runAuthLogin(flags, env, io) {
+  let token = flags.token || env.DEEPFLOW_TOKEN || null;
+
+  if (flags.tokenStdin) {
+    token = await readStdin(io);
+  }
+
+  requireToken(token);
+
+  const runtimeConfig = await resolveRuntimeConfig({ ...flags, token }, env);
+  const client = makeClient({ ...runtimeConfig, token }, flags);
+  const reachableBaseUrl = await resolveReachableBaseUrl(client);
+
+  await client.verifyToken("auth.login");
+
+  const saved = await saveAuthConfig({
+    baseUrl: reachableBaseUrl,
+    token,
+    profile: runtimeConfig.profile,
+  }, env);
+
+  return {
+    ok: true,
+    method: "auth.login",
+    authenticated: true,
+    baseUrl: reachableBaseUrl,
+    profile: runtimeConfig.profile,
+    tokenPrefix: redactToken(token),
+    configPath: saved.configPath,
+  };
+}
+
+async function runAuthLogout(flags, env) {
+  const profile = flags.profile || env.DEEPFLOW_PROFILE || DEFAULT_PROFILE;
+  const result = await clearAuthConfig(profile, env);
+
+  return {
+    ok: true,
+    method: "auth.logout",
+    profile,
+    configPath: result.configPath,
+  };
+}
+
+async function runAuthStatus(flags, env) {
+  const runtimeConfig = await resolveRuntimeConfig(flags, env);
+  const result = {
+    ok: true,
+    method: "auth.status",
+    authenticated: Boolean(runtimeConfig.token),
+    baseUrl: runtimeConfig.baseUrl,
+    profile: runtimeConfig.profile,
+    tokenPrefix: runtimeConfig.token ? redactToken(runtimeConfig.token) : null,
+    configPath: runtimeConfig.configPath,
+    status: null,
+  };
+
+  if (!runtimeConfig.token) {
+    return result;
+  }
+
+  const client = makeClient(runtimeConfig, flags);
+
+  try {
+    result.baseUrl = await resolveReachableBaseUrl(client);
+    await client.verifyToken("auth.status");
+    result.status = "valid";
+  } catch (error) {
+    result.authenticated = false;
+    result.status = error.code || "invalid";
+  }
+
+  return result;
+}
+
+async function runAppsList(flags, env) {
+  const runtimeConfig = await resolveRuntimeConfig(flags, env);
+  requireToken(runtimeConfig.token);
+  const client = makeClient(runtimeConfig, flags);
+  const reachableBaseUrl = await resolveReachableBaseUrl(client);
+  const items = await client.listApps();
+
+  return {
+    ok: true,
+    method: "apps.list",
+    baseUrl: reachableBaseUrl,
+    items,
+  };
+}
+
+async function resolveRepoRef(client, flags) {
+  if (flags.repo) {
+    return flags.repo;
+  }
+
+  const apps = await client.listApps();
+  const first = apps.find((app) => app.repositoryUrl);
+
+  if (!first) {
+    throw new CliError("No app is available. Pass --repo <repo_id_or_app_code> after adding an app.", {
+      code: "missing_repo",
+      exitCode: 2,
+    });
+  }
+
+  return first.id || first.appCode;
+}
+
+async function runPlanRun(flags, env) {
+  const runtimeConfig = await resolveRuntimeConfig(flags, env);
+  requireToken(runtimeConfig.token);
+
+  if (flags.runtime && !["claude", "codex"].includes(flags.runtime)) {
+    throw new CliError("--runtime must be claude or codex.", {
+      code: "bad_runtime",
+      exitCode: 2,
+    });
+  }
+
+  const client = makeClient(runtimeConfig, flags);
+  const reachableBaseUrl = await resolveReachableBaseUrl(client);
+  const repoRef = await resolveRepoRef(client, flags);
+  const context = await readTextOption(flags, {
+    textName: "context",
+    fileName: "contextFile",
+    fallback: "DeepFlow CLI plan run.",
+  });
+  const prompt = await readTextOption(flags, {
+    textName: "prompt",
+    fileName: "promptFile",
+    fallback:
+      "Please create a detailed implementation plan for this iteration. Analyze the repository first, identify risks, and propose validation steps. Do not modify code yet.",
+  });
+  const iterationName = flags.name || `CLI Plan ${new Date().toISOString()}`;
+  const iteration = await client.createIteration({
+    name: iterationName,
+    repoIds: [repoRef],
+    repoBranches: buildRepoBranches(repoRef, flags),
+    iterationType: flags.iterationType ?? "feature",
+    context,
+  });
+  const repoId = resolveRepoIdFromIteration(iteration, repoRef);
+  const sessionPayload = {
+    iterationId: iteration.id,
+    repoId,
+    forceNew: flags.forceNew !== false,
+  };
+
+  if (flags.runtime) {
+    sessionPayload.runtimeType = flags.runtime;
+  }
+
+  const sessionResult = await client.createPlanSession(sessionPayload);
+  const session = sessionResult.session;
+
+  if (!session?.session_id) {
+    throw new CliError("Plan session response did not include session.session_id.", {
+      code: "bad_response",
+      exitCode: 1,
+    });
+  }
+
+  const runResult = await client.sendPlanMessage({
+    localIterationId: iteration.id,
+    sessionId: session.session_id,
+    prompt,
+  });
+  const links = buildSessionLinks(reachableBaseUrl, {
+    localIterationId: iteration.id,
+    backendIterationId: iteration.backendIterationId,
+    sessionId: session.session_id,
+  });
+
+  return {
+    ok: true,
+    method: "plan.run",
+    baseUrl: reachableBaseUrl,
+    iterationId: iteration.id,
+    backendIterationId: iteration.backendIterationId,
+    iterationName: iteration.name,
+    repoId,
+    planSessionId: session.session_id,
+    runId: runResult?.run?.run_id ?? runResult?.run?.id ?? null,
+    accepted: runResult?.accepted ?? null,
+    uiUrl: buildUiUrl(reachableBaseUrl, iteration, session.session_id),
+    ...links,
+  };
+}
+
+async function runPlanStatus(flags, env) {
+  const localIterationId = requireOption(flags, "iteration", "--iteration <local_iteration_id> is required.");
+  const sessionId = requireOption(flags, "session", "--session <session_id> is required.");
+  const runtimeConfig = await resolveRuntimeConfig(flags, env);
+  requireToken(runtimeConfig.token);
+  const client = makeClient(runtimeConfig, flags);
+  const reachableBaseUrl = await resolveReachableBaseUrl(client);
+  const session = await client.getLocalSession({
+    localIterationId,
+    sessionId,
+  });
+
+  return {
+    ok: true,
+    method: "plan.status",
+    baseUrl: reachableBaseUrl,
+    iterationId: localIterationId,
+    sessionId,
+    status: session?.status ?? session?.run_status ?? null,
+    session,
+  };
+}
+
+async function runSessionMessages(flags, env) {
+  const sessionId = requireOption(flags, "session", "--session <session_id> is required.");
+  const backendIterationId = flags.backendIteration || flags.iteration;
+
+  if (!backendIterationId) {
+    throw new CliError("--backend-iteration <backend_iteration_id> is required.", {
+      code: "missing_argument",
+      exitCode: 2,
+    });
+  }
+
+  const runtimeConfig = await resolveRuntimeConfig(flags, env);
+  requireToken(runtimeConfig.token);
+  const client = makeClient(runtimeConfig, flags);
+  const reachableBaseUrl = await resolveReachableBaseUrl(client);
+  const messages = await client.listMessages({
+    backendIterationId,
+    sessionId,
+  });
+
+  return {
+    ok: true,
+    method: "session.messages",
+    baseUrl: reachableBaseUrl,
+    backendIterationId,
+    sessionId,
+    messages,
+  };
+}
+
+async function runSessionStop(flags, env) {
+  const sessionId = requireOption(flags, "session", "--session <session_id> is required.");
+  const backendIterationId = flags.backendIteration || flags.iteration;
+
+  if (!backendIterationId) {
+    throw new CliError("--backend-iteration <backend_iteration_id> is required.", {
+      code: "missing_argument",
+      exitCode: 2,
+    });
+  }
+
+  const runtimeConfig = await resolveRuntimeConfig(flags, env);
+  requireToken(runtimeConfig.token);
+  const client = makeClient(runtimeConfig, flags);
+  const reachableBaseUrl = await resolveReachableBaseUrl(client);
+  const response = await client.stopSession({
+    backendIterationId,
+    sessionId,
+  });
+
+  return {
+    ok: true,
+    method: "session.stop",
+    baseUrl: reachableBaseUrl,
+    backendIterationId,
+    sessionId,
+    response,
+  };
+}
+
+async function dispatch(command, flags, env, io) {
+  const [domain, action] = command;
+
+  if (!domain) {
+    throw new CliError("Missing command. Run deepflow --help.", {
+      code: "missing_command",
+      exitCode: 2,
+    });
+  }
+
+  if (domain === "auth" && action === "login") {
+    return runAuthLogin(flags, env, io);
+  }
+
+  if (domain === "auth" && action === "logout") {
+    return runAuthLogout(flags, env);
+  }
+
+  if (domain === "auth" && action === "status") {
+    return runAuthStatus(flags, env);
+  }
+
+  if (domain === "apps" && action === "list") {
+    return runAppsList(flags, env);
+  }
+
+  if (domain === "plan" && action === "run") {
+    return runPlanRun(flags, env);
+  }
+
+  if (domain === "plan" && action === "status") {
+    return runPlanStatus(flags, env);
+  }
+
+  if (domain === "session" && action === "messages") {
+    return runSessionMessages(flags, env);
+  }
+
+  if (domain === "session" && action === "stop") {
+    return runSessionStop(flags, env);
+  }
+
+  throw new CliError(`Unknown command: ${command.join(" ")}`, {
+    code: "unknown_command",
+    exitCode: 2,
+  });
+}
+
+export async function main(argv = process.argv.slice(2), {
+  env = process.env,
+  io = buildIo(),
+} = {}) {
+  let parsed;
+
+  try {
+    parsed = parseArgs(argv);
+
+    if (parsed.flags.help) {
+      io.stdout.write(helpText());
+      return 0;
+    }
+
+    if (parsed.flags.version) {
+      io.stdout.write(`${VERSION}\n`);
+      return 0;
+    }
+
+    const command = commandFromParsedArgs(parsed);
+    const result = await dispatch(command, parsed.flags, env, io);
+    writeResult(io, result, { json: parsed.flags.json });
+
+    return 0;
+  } catch (error) {
+    return writeError(io, error, { json: parsed?.flags?.json });
+  }
+}