@treeseed/cli 0.1.1 → 0.4.0

package/README.md

@@ -2,22 +2,22 @@
 
 Operator-facing Treeseed CLI package.
 
-This package publishes the `treeseed` binary. It provides the unified TypeScript command interface for Treeseed workspace setup, branch workflow, deployment, validation, and release automation.
+This package publishes the `treeseed` binary. `@treeseed/sdk` owns the reusable workflow and runtime capabilities; `@treeseed/cli` owns argv parsing, command help, terminal formatting, command handlers, and the installable executable surface.
 
 ## Requirements
 
-- Node `>=20`
+- Node `>=22`
 - npm as the canonical package manager for install, CI, and release flows
 
 ## Install
 
-Install the CLI alongside the Treeseed runtime package:
+Install the CLI with its runtime dependencies:
 
 ```bash
-npm install @treeseed/cli @treeseed/core
+npm install @treeseed/cli @treeseed/sdk @treeseed/agent
 ```
 
-`@treeseed/cli` depends on `@treeseed/core`, `@treeseed/sdk`, and `@treeseed/agent` at package runtime. In normal consumer installs, npm resolves those package dependencies automatically.
+`@treeseed/cli` is a thin installable wrapper over `@treeseed/sdk` workflow and operations interfaces plus the `@treeseed/agent` command namespace. In normal consumer installs, npm resolves the runtime dependencies automatically.
 
 After installation, the published binary is available as:
 
@@ -29,36 +29,37 @@ treeseed --help
 
 The main workflow commands exposed by the current CLI are:
 
-- `treeseed setup`
-- `treeseed work <branch-name> [--preview]`
-- `treeseed ship "<commit message>"`
-- `treeseed publish --environment <local|staging|prod>`
-- `treeseed promote --major|--minor|--patch`
-- `treeseed rollback <staging|prod> [--to <deploy-id|commit>]`
-- `treeseed teardown [--environment <local|staging|prod>]`
 - `treeseed status [--json]`
-- `treeseed next [--json]`
-- `treeseed continue [--json]`
-- `treeseed doctor [--fix] [--json]`
-
-The CLI also keeps compatibility commands such as `init`, `config`, `start`, `deploy`, `save`, `release`, `close`, and `destroy`.
+- `treeseed config`
+- `treeseed tasks [--json]`
+- `treeseed switch <branch-name> [--preview]`
+- `treeseed dev`
+- `treeseed save "<commit message>"`
+- `treeseed stage "<resolution message>"`
+- `treeseed close "<close reason>"`
+- `treeseed release --major|--minor|--patch`
+- `treeseed destroy --environment <local|staging|prod>`
+
+Support utilities such as `treeseed rollback`, `treeseed doctor`, `treeseed auth:*`, `treeseed template`, `treeseed sync`, `treeseed lint`, `treeseed test`, `treeseed build`, service helpers, and `treeseed agents ...` remain available.
 
 Use `treeseed help` for the full command list and `treeseed help <command>` for command-specific usage, options, and examples.
 
 ## Common Commands
 
 ```bash
-treeseed setup
-treeseed work feature/search-improvements --preview
-treeseed ship "feat: add search filters"
-treeseed publish --environment staging
-treeseed promote --patch
+treeseed status
+treeseed config
+treeseed switch feature/search-improvements --preview
+treeseed dev
+treeseed save "feat: add search filters"
+treeseed stage "feat: add search filters"
+treeseed release --patch
 treeseed status --json
 ```
 
 ## Maintainer Workflow
 
-All package maintenance commands are npm-based and run from the `cli/` package root.
+All package maintenance commands are npm-based and run from the `cli/` package root. This package verifies the published command surface, parser/help behavior, and packaged artifact shape.
 
 Install dependencies:
 
@@ -88,8 +89,8 @@ The release verification flow is intentionally stricter than a normal test run:
 
 1. Build `dist`
 2. Validate publishable output for forbidden workspace references
-3. Run the CLI test suite
-4. Run scaffold verification
+3. Assert the published artifact only contains the thin wrapper entrypoints
+4. Run the CLI wrapper test suite
 5. Pack the CLI tarball
 6. Smoke-test the packed install by running `treeseed --help` from the packed artifact
 
@@ -112,4 +113,4 @@ For example, package version `0.1.0` publishes from tag `0.1.0`.
 ## Notes
 
 - `package-lock.json` should be committed and kept current so `npm ci` remains reproducible in CI and release jobs.
-- The README intentionally documents the command surface at a high level. The canonical source of command usage and options is the CLI help output generated from `src/cli/registry.ts`.
+- The README intentionally documents the command surface at a high level. The canonical source of operation identity and semantics is `@treeseed/sdk`, while `@treeseed/cli` owns argv parsing, help rendering, and terminal formatting.

package/dist/cli/handlers/auth-login.d.ts

@@ -0,0 +1,2 @@
+import type { TreeseedCommandHandler } from '../types.js';
+export declare const handleAuthLogin: TreeseedCommandHandler;

package/dist/cli/handlers/auth-login.js

@@ -0,0 +1,67 @@
+import { RemoteTreeseedAuthClient, RemoteTreeseedClient } from "@treeseed/sdk/remote";
+import {
+  resolveTreeseedRemoteConfig,
+  setTreeseedRemoteSession
+} from "@treeseed/sdk/workflow-support";
+import { guidedResult } from "./utils.js";
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+const handleAuthLogin = async (invocation, context) => {
+  const tenantRoot = context.cwd;
+  const remoteConfig = resolveTreeseedRemoteConfig(tenantRoot, context.env);
+  const hostId = typeof invocation.args.host === "string" ? invocation.args.host : remoteConfig.activeHostId;
+  const client = new RemoteTreeseedAuthClient(new RemoteTreeseedClient({
+    ...remoteConfig,
+    activeHostId: hostId
+  }));
+  const started = await client.startDeviceFlow({
+    clientName: "treeseed-cli",
+    scopes: ["auth:me", "sdk", "operations"]
+  });
+  if (context.outputFormat !== "json") {
+    context.write(`Open ${started.verificationUriComplete}`, "stdout");
+    context.write(`User code: ${started.userCode}`, "stdout");
+    context.write("Waiting for approval...", "stdout");
+  }
+  const deadline = Date.parse(started.expiresAt);
+  while (Date.now() < deadline) {
+    const response = await client.pollDeviceFlow({ deviceCode: started.deviceCode });
+    if (response.ok && response.status === "approved") {
+      setTreeseedRemoteSession(tenantRoot, {
+        hostId,
+        accessToken: response.accessToken,
+        refreshToken: response.refreshToken,
+        expiresAt: response.expiresAt,
+        principal: response.principal
+      });
+      return guidedResult({
+        command: "auth:login",
+        summary: "Treeseed API login completed successfully.",
+        facts: [
+          { label: "Host", value: hostId },
+          { label: "Principal", value: response.principal.displayName ?? response.principal.id },
+          { label: "Scopes", value: response.principal.scopes.join(", ") }
+        ],
+        report: {
+          hostId,
+          principal: response.principal
+        }
+      });
+    }
+    if (!response.ok && response.status !== "already_used") {
+      return {
+        exitCode: 1,
+        stderr: [response.error]
+      };
+    }
+    await sleep(started.intervalSeconds * 1e3);
+  }
+  return {
+    exitCode: 1,
+    stderr: ["Treeseed API login expired before approval completed."]
+  };
+};
+export {
+  handleAuthLogin
+};

package/dist/cli/handlers/auth-logout.d.ts

@@ -0,0 +1,2 @@
+import type { TreeseedCommandHandler } from '../types.js';
+export declare const handleAuthLogout: TreeseedCommandHandler;

package/dist/cli/handlers/auth-logout.js

@@ -0,0 +1,20 @@
+import {
+  clearTreeseedRemoteSession,
+  resolveTreeseedRemoteConfig
+} from "@treeseed/sdk/workflow-support";
+import { guidedResult } from "./utils.js";
+const handleAuthLogout = async (invocation, context) => {
+  const tenantRoot = context.cwd;
+  const remoteConfig = resolveTreeseedRemoteConfig(tenantRoot, context.env);
+  const hostId = typeof invocation.args.host === "string" ? invocation.args.host : remoteConfig.activeHostId;
+  clearTreeseedRemoteSession(tenantRoot, hostId);
+  return guidedResult({
+    command: "auth:logout",
+    summary: "Cleared the local Treeseed API session.",
+    facts: [{ label: "Host", value: hostId }],
+    report: { hostId }
+  });
+};
+export {
+  handleAuthLogout
+};

package/dist/cli/handlers/auth-whoami.d.ts

@@ -0,0 +1,2 @@
+import type { TreeseedCommandHandler } from '../types.js';
+export declare const handleAuthWhoAmI: TreeseedCommandHandler;

package/dist/cli/handlers/auth-whoami.js

@@ -0,0 +1,24 @@
+import { RemoteTreeseedAuthClient, RemoteTreeseedClient } from "@treeseed/sdk/remote";
+import { resolveTreeseedRemoteConfig } from "@treeseed/sdk/workflow-support";
+import { guidedResult } from "./utils.js";
+const handleAuthWhoAmI = async (_invocation, context) => {
+  const remoteConfig = resolveTreeseedRemoteConfig(context.cwd, context.env);
+  const client = new RemoteTreeseedAuthClient(new RemoteTreeseedClient(remoteConfig));
+  const response = await client.whoAmI();
+  return guidedResult({
+    command: "auth:whoami",
+    summary: "Treeseed API identity",
+    facts: [
+      { label: "Host", value: remoteConfig.activeHostId },
+      { label: "Principal", value: response.payload.displayName ?? response.payload.id },
+      { label: "Scopes", value: response.payload.scopes.join(", ") }
+    ],
+    report: {
+      hostId: remoteConfig.activeHostId,
+      principal: response.payload
+    }
+  });
+};
+export {
+  handleAuthWhoAmI
+};

package/dist/cli/handlers/close.js

@@ -1,59 +1,25 @@
-import { applyTreeseedEnvironmentToProcess } from "../../scripts/config-runtime-lib.js";
-import {
-  cleanupDestroyedState,
-  createBranchPreviewDeployTarget,
-  destroyCloudflareResources,
-  loadDeployState,
-  printDestroySummary,
-  validateDestroyPrerequisites
-} from "../../scripts/deploy-lib.js";
-import {
-  assertFeatureBranch,
-  deleteLocalBranch,
-  deleteRemoteBranch,
-  mergeCurrentBranchIntoStaging
-} from "../../scripts/git-workflow-lib.js";
-import { loadCliDeployConfig } from "../../scripts/package-tools.js";
-import { runWorkspaceSavePreflight } from "../../scripts/save-deploy-preflight-lib.js";
 import { guidedResult } from "./utils.js";
-const handleClose = (_invocation, context) => {
-  const commandName = _invocation.commandName || "close";
-  const tenantRoot = context.cwd;
-  const featureBranch = assertFeatureBranch(tenantRoot);
-  const previewTarget = createBranchPreviewDeployTarget(featureBranch);
-  const deployConfig = loadCliDeployConfig(tenantRoot);
-  const previewState = loadDeployState(tenantRoot, deployConfig, { target: previewTarget });
-  runWorkspaceSavePreflight({ cwd: tenantRoot });
-  const repoDir = mergeCurrentBranchIntoStaging(tenantRoot, featureBranch);
-  if (previewState.readiness?.initialized) {
-    applyTreeseedEnvironmentToProcess({ tenantRoot, scope: "staging" });
-    validateDestroyPrerequisites(tenantRoot, { requireRemote: true });
-    const result = destroyCloudflareResources(tenantRoot, { target: previewTarget });
-    printDestroySummary(result);
-  }
-  cleanupDestroyedState(tenantRoot, { target: previewTarget });
-  deleteRemoteBranch(repoDir, featureBranch);
-  deleteLocalBranch(repoDir, featureBranch);
-  return {
-    ...guidedResult({
-      command: commandName,
-      summary: `Treeseed ${commandName} completed successfully.`,
+import { createWorkflowSdk, renderWorkflowNextSteps, workflowErrorResult } from "./workflow.js";
+const handleClose = async (invocation, context) => {
+  try {
+    const result = await createWorkflowSdk(context).close({
+      message: invocation.positionals.join(" ").trim()
+    });
+    const payload = result.payload;
+    return guidedResult({
+      command: invocation.commandName || "close",
+      summary: "Treeseed close completed successfully.",
       facts: [
-        { label: "Merged branch", value: featureBranch },
-        { label: "Merge target", value: "staging" },
-        { label: "Preview cleanup", value: previewState.readiness?.initialized ? "performed" : "not needed" }
-      ],
-      nextSteps: [
-        "treeseed deploy --environment staging",
-        "treeseed release --patch"
+        { label: "Closed branch", value: payload.branchName },
+        { label: "Deprecated tag", value: payload.deprecatedTag.tagName },
+        { label: "Preview cleanup", value: payload.previewCleanup.performed ? "performed" : "not needed" }
       ],
-      report: {
-        branchName: featureBranch,
-        mergeTarget: "staging",
-        previewCleanup: previewState.readiness?.initialized === true
-      }
-    })
-  };
+      nextSteps: renderWorkflowNextSteps(result),
+      report: payload
+    });
+  } catch (error) {
+    return workflowErrorResult(error);
+  }
 };
 export {
   handleClose

package/dist/cli/handlers/config.js

@@ -1,72 +1,52 @@
 import readline from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
-import { collectCliPreflight } from "../../scripts/workspace-preflight-lib.js";
-import {
-  applyTreeseedEnvironmentToProcess,
-  ensureTreeseedGitignoreEntries,
-  getTreeseedMachineConfigPaths,
-  runTreeseedConfigWizard,
-  writeTreeseedLocalEnvironmentFiles
-} from "../../scripts/config-runtime-lib.js";
 import { guidedResult } from "./utils.js";
+import { createWorkflowSdk, renderWorkflowNextSteps, workflowErrorResult } from "./workflow.js";
 const handleConfig = async (invocation, context) => {
-  const commandName = invocation.commandName || "config";
-  const tenantRoot = context.cwd;
-  const scopes = Array.isArray(invocation.args.environment) ? invocation.args.environment : invocation.args.environment ? [invocation.args.environment] : ["local", "staging", "prod"];
-  const sync = typeof invocation.args.sync === "string" ? invocation.args.sync : "none";
-  ensureTreeseedGitignoreEntries(tenantRoot);
-  const preflight = collectCliPreflight({ cwd: tenantRoot, requireAuth: false });
   const rl = readline.createInterface({ input, output });
   try {
-    if (context.outputFormat !== "json") {
-      context.write("Treeseed configuration wizard", "stdout");
-      context.write("This command writes a local machine config, generates .env.local and .dev.vars, and can sync GitHub or Cloudflare settings.", "stdout");
-      context.write('Enter a value to set it, press Enter to keep the current/default value, or enter "-" to clear a value.\n', "stdout");
-    }
-    const result = await runTreeseedConfigWizard({
-      tenantRoot,
-      scopes,
-      sync,
-      authStatus: preflight.checks.auth,
-      write: context.outputFormat === "json" ? () => {
-      } : ((line) => context.write(line, "stdout")),
+    const workflow = createWorkflowSdk(context, {
+      write: context.outputFormat === "json" ? (() => {
+      }) : context.write,
       prompt: async (message) => {
         if (!process.stdin.isTTY || !process.stdout.isTTY) {
           return "";
         }
-        try {
-          return await rl.question(message);
-        } catch {
-          return "";
-        }
+        return rl.question(message);
       }
     });
-    writeTreeseedLocalEnvironmentFiles(tenantRoot);
-    applyTreeseedEnvironmentToProcess({ tenantRoot, scope: "local" });
-    const { configPath, keyPath } = getTreeseedMachineConfigPaths(tenantRoot);
+    const result = await workflow.config({
+      environment: invocation.args.environment,
+      sync: invocation.args.sync,
+      printEnv: invocation.args.printEnv === true,
+      printEnvOnly: invocation.args.printEnvOnly === true,
+      showSecrets: invocation.args.showSecrets === true,
+      rotateMachineKey: invocation.args.rotateMachineKey === true,
+      nonInteractive: context.outputFormat === "json"
+    });
+    const payload = result.payload;
+    const toolHealth = payload.toolHealth;
+    const summary = payload.mode === "print-env-only" ? "Treeseed config environment report completed." : payload.mode === "rotate-machine-key" ? "Treeseed machine key rotated successfully." : "Treeseed config completed successfully.";
     return guidedResult({
-      command: commandName,
-      summary: `Treeseed ${commandName} completed successfully.`,
+      command: invocation.commandName || "config",
+      summary,
       facts: [
-        { label: "Machine config", value: configPath },
-        { label: "Machine key", value: keyPath },
-        { label: "Updated values", value: result.updated.length },
-        { label: "Initialized environments", value: result.initialized.map((entry) => entry.scope).join(", ") || "(none)" },
-        { label: "GitHub sync", value: result.synced.github ? `${result.synced.github.secrets.length} secrets, ${result.synced.github.variables.length} variables` : "not run" },
-        { label: "Cloudflare sync", value: result.synced.cloudflare ? `${result.synced.cloudflare.secrets.length} secrets, ${result.synced.cloudflare.varsManagedByWranglerConfig.length} vars` : "not run" }
+        { label: "Mode", value: payload.mode },
+        { label: "Scopes", value: Array.isArray(payload.scopes) ? payload.scopes.join(", ") : "(none)" },
+        { label: "Sync", value: payload.sync ?? "all" },
+        { label: "Safe repairs", value: Array.isArray(payload.repairs) ? payload.repairs.length : 0 },
+        { label: "Machine config", value: payload.configPath },
+        { label: "Machine key", value: payload.keyPath },
+        { label: "GitHub CLI", value: toolHealth?.githubCli?.available ? "ready" : "missing" },
+        { label: "gh act", value: toolHealth?.ghActExtension?.available ? "ready" : "missing" },
+        { label: "Docker", value: toolHealth?.dockerDaemon?.available ? "ready" : "missing" },
+        { label: "ACT verify", value: toolHealth?.actVerificationReady ? "ready" : "not ready" }
       ],
-      nextSteps: [
-        ...scopes.includes("local") ? ["treeseed dev"] : [],
-        ...scopes.includes("staging") ? ["treeseed deploy --environment staging"] : [],
-        ...scopes.includes("prod") ? ["treeseed deploy --environment prod"] : []
-      ],
-      report: {
-        scopes,
-        sync,
-        result,
-        preflight
-      }
+      nextSteps: renderWorkflowNextSteps(result),
+      report: payload
     });
+  } catch (error) {
+    return workflowErrorResult(error);
   } finally {
     rl.close();
   }

package/dist/cli/handlers/destroy.js

@@ -1,93 +1,48 @@
 import readline from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
-import { applyTreeseedEnvironmentToProcess, assertTreeseedCommandEnvironment } from "../../scripts/config-runtime-lib.js";
-import {
-  cleanupDestroyedState,
-  createPersistentDeployTarget,
-  destroyCloudflareResources,
-  loadDeployState,
-  printDestroySummary,
-  validateDestroyPrerequisites
-} from "../../scripts/deploy-lib.js";
 import { guidedResult } from "./utils.js";
-function printDangerMessage(context, deployConfig, state, expectedConfirmation) {
-  context.write("DANGER: treeseed destroy will permanently delete this site and its Cloudflare resources.", "stderr");
-  context.write(`  Site: ${deployConfig.name}`, "stderr");
-  context.write(`  Slug: ${deployConfig.slug}`, "stderr");
-  context.write(`  Worker: ${state.workerName}`, "stderr");
-  context.write(`  D1: ${state.d1Databases.SITE_DATA_DB.databaseName}`, "stderr");
-  context.write(`  KV FORM_GUARD_KV: ${state.kvNamespaces.FORM_GUARD_KV.name}`, "stderr");
-  context.write(`  KV SESSION: ${state.kvNamespaces.SESSION.name}`, "stderr");
-  context.write("  This action is irreversible.", "stderr");
-  context.write(`  To continue, type exactly: ${expectedConfirmation}`, "stderr");
+import { createWorkflowSdk, renderWorkflowNextSteps, workflowErrorResult } from "./workflow.js";
+async function promptForConfirmation(expected) {
+  const rl = readline.createInterface({ input, output });
+  try {
+    return (await rl.question("Confirmation: ")).trim();
+  } finally {
+    rl.close();
+  }
 }
 const handleDestroy = async (invocation, context) => {
-  const commandName = invocation.commandName || "destroy";
-  const tenantRoot = context.cwd;
-  const scope = String(invocation.args.environment);
-  const target = createPersistentDeployTarget(scope);
-  const dryRun = invocation.args.dryRun === true;
-  const force = invocation.args.force === true;
-  const skipConfirmation = invocation.args.skipConfirmation === true;
-  const confirm = typeof invocation.args.confirm === "string" ? invocation.args.confirm : null;
-  const removeBuildArtifacts = invocation.args.removeBuildArtifacts === true;
-  applyTreeseedEnvironmentToProcess({ tenantRoot, scope });
-  assertTreeseedCommandEnvironment({ tenantRoot, scope, purpose: "destroy" });
-  const deployConfig = validateDestroyPrerequisites(tenantRoot, { requireRemote: !dryRun });
-  const state = loadDeployState(tenantRoot, deployConfig, { target });
-  const expectedConfirmation = deployConfig.slug;
-  if (!skipConfirmation) {
-    printDangerMessage(context, deployConfig, state, expectedConfirmation);
-    const confirmed = confirm !== null ? confirm === expectedConfirmation : await (async () => {
-      const rl = readline.createInterface({ input, output });
-      try {
-        return (await rl.question("Confirmation: ")).trim() === expectedConfirmation;
-      } finally {
-        rl.close();
+  try {
+    const result = await createWorkflowSdk(context, {
+      confirm: async (_message, expected) => {
+        if (typeof invocation.args.confirm === "string") {
+          return invocation.args.confirm === expected;
+        }
+        if (invocation.args.skipConfirmation === true || context.outputFormat === "json" || !process.stdin.isTTY || !process.stdout.isTTY) {
+          return false;
+        }
+        return await promptForConfirmation(expected) === expected;
       }
-    })();
-    if (!confirmed) {
-      return { exitCode: 1, stderr: ["Destroy aborted: confirmation text did not match."] };
-    }
-  }
-  const result = destroyCloudflareResources(tenantRoot, { dryRun, force, target });
-  printDestroySummary(result);
-  if (dryRun) {
+    }).destroy({
+      environment: String(invocation.args.environment),
+      dryRun: invocation.args.dryRun === true,
+      force: invocation.args.force === true,
+      removeBuildArtifacts: invocation.args.removeBuildArtifacts === true
+    });
+    const payload = result.payload;
     return guidedResult({
-      command: commandName,
-      summary: `Treeseed ${commandName} dry run completed.`,
+      command: invocation.commandName || "destroy",
+      summary: payload.dryRun ? "Treeseed destroy dry run completed." : "Treeseed destroy completed successfully.",
       facts: [
-        { label: "Environment", value: scope },
-        { label: "Remote deletion", value: "skipped" }
+        { label: "Environment", value: payload.scope },
+        { label: "Dry run", value: payload.dryRun ? "yes" : "no" },
+        { label: "Removed build artifacts", value: payload.removeBuildArtifacts ? "yes" : "no" }
       ],
-      nextSteps: ["treeseed status"],
-      report: {
-        scope,
-        dryRun: true,
-        force,
-        removeBuildArtifacts
-      }
+      nextSteps: renderWorkflowNextSteps(result),
+      report: payload
     });
+  } catch (error) {
+    return workflowErrorResult(error);
   }
-  cleanupDestroyedState(tenantRoot, { target, removeBuildArtifacts });
-  return guidedResult({
-    command: commandName,
-    summary: `Treeseed ${commandName} completed and local deployment state was removed.`,
-    facts: [
-      { label: "Environment", value: scope },
-      { label: "Removed build artifacts", value: removeBuildArtifacts ? "yes" : "no" }
-    ],
-    nextSteps: [
-      `treeseed config --environment ${scope}`,
-      "treeseed status"
-    ],
-    report: {
-      scope,
-      dryRun: false,
-      force,
-      removeBuildArtifacts
-    }
-  });
 };
 export {
   handleDestroy

package/dist/{src/cli/handlers/ship.d.ts → cli/handlers/dev.d.ts}

@@ -1,2 +1,2 @@
 import type { TreeseedCommandHandler } from '../types.js';
-export declare const handleShip: TreeseedCommandHandler;
+export declare const handleDev: TreeseedCommandHandler;

package/dist/cli/handlers/dev.js

@@ -0,0 +1,19 @@
+import { createWorkflowSdk, workflowErrorResult } from "./workflow.js";
+const handleDev = async (invocation, context) => {
+  try {
+    const result = await createWorkflowSdk(context).dev({
+      watch: invocation.commandName === "dev:watch" || invocation.args.watch === true,
+      background: false,
+      stdio: "inherit"
+    });
+    return {
+      exitCode: result.ok ? 0 : 1,
+      report: result.payload
+    };
+  } catch (error) {
+    return workflowErrorResult(error);
+  }
+};
+export {
+  handleDev
+};

package/dist/cli/handlers/doctor.js

@@ -1,4 +1,4 @@
-import { collectCliPreflight } from "../../scripts/workspace-preflight-lib.js";
+import { collectCliPreflight } from "@treeseed/sdk/workflow-support";
 import { guidedResult } from "./utils.js";
 import { resolveTreeseedWorkflowState } from "../workflow-state.js";
 import { applyTreeseedSafeRepairs } from "../repair.js";
@@ -6,19 +6,26 @@ const handleDoctor = (invocation, context) => {
   const performedFixes = invocation.args.fix === true && resolveTreeseedWorkflowState(context.cwd).deployConfigPresent ? applyTreeseedSafeRepairs(context.cwd) : [];
   const state = resolveTreeseedWorkflowState(context.cwd);
   const preflight = collectCliPreflight({ cwd: context.cwd, requireAuth: false });
+  const railwayManagedServicesEnabled = Object.values(state.managedServices).some((service) => service.enabled);
   const mustFixNow = [];
   const optional = [];
-  if (!state.workspaceRoot) mustFixNow.push("Run Treeseed from the workspace root so package commands and workflow state resolve correctly.");
-  if (!state.repoRoot) mustFixNow.push("Initialize or clone the git repository before using save, close, deploy, or release flows.");
+  if (!state.workspaceRoot) mustFixNow.push("Run Treeseed inside a Treeseed workspace so package commands and workflow state can resolve correctly.");
+  if (!state.repoRoot) mustFixNow.push("Initialize or clone the git repository before using save, close, stage, or release flows.");
   if (!state.deployConfigPresent) mustFixNow.push("Create or restore treeseed.site.yaml so the tenant contract can be loaded.");
   if (preflight.missingCommands.includes("git")) mustFixNow.push("Install Git.");
   if (preflight.missingCommands.includes("npm")) mustFixNow.push("Install npm 10 or newer.");
   if (!state.files.machineConfig) mustFixNow.push("Run `treeseed config --environment local` to create the local machine config.");
   if (!state.files.envLocal) optional.push("Create `.env.local` or run `treeseed config --environment local` to generate it.");
   if (!state.files.devVars) optional.push("Generate `.dev.vars` by running `treeseed config --environment local`.");
-  if (!state.auth.gh) optional.push("Authenticate `gh` if you want GitHub-backed save or release automation.");
-  if (!state.auth.wrangler) optional.push("Authenticate `wrangler` before staging, preview, or production deployment work.");
-  if (!state.auth.copilot) optional.push("Configure Copilot CLI only if you rely on local Copilot-assisted workflows.");
+  if (!state.auth.gh) optional.push("Configure `GH_TOKEN` for GitHub CLI automation and Copilot-backed workflows.");
+  if (!state.auth.wrangler) optional.push("Configure `CLOUDFLARE_API_TOKEN` before staging, preview, or production deployment work.");
+  if (!state.auth.railway && railwayManagedServicesEnabled) {
+    optional.push("Configure `RAILWAY_API_TOKEN` before deploying the managed Railway services.");
+  }
+  if (!state.auth.remoteApi && state.managedServices.api.enabled) {
+    optional.push("Run `treeseed auth:login` so the CLI can use the configured remote API.");
+  }
+  if (!state.auth.copilot) optional.push("Configure `GH_TOKEN` if you rely on local Copilot-assisted workflows.");
   return guidedResult({
     command: "doctor",
     summary: mustFixNow.length === 0 ? "Treeseed doctor found no blocking issues." : "Treeseed doctor found issues that need attention.",