@treeseed/cli 0.10.6 → 0.10.7

package/dist/cli/handlers/dev.js

@@ -44,11 +44,11 @@ function resolveCoreDevEntrypoint(cwd) {
 const handleDev = async (invocation, context) => {
   try {
     if (invocation.commandName !== "dev") {
-      return fail("`trsd dev` only starts the Market web/API dev runtime. Use `trsd capacity ...` for capacity provider lifecycle commands.");
+      return fail("`trsd dev` starts the Market web/API/dev-runner runtime. Use `trsd capacity ...` for capacity provider lifecycle commands.");
     }
     const removedOptions = ["surface", "surfaces", "withWorker"].filter((name) => invocation.args[name] !== void 0);
     if (removedOptions.length > 0) {
-      return fail(`\`trsd dev\` no longer accepts ${removedOptions.map((name) => `--${name.replace(/[A-Z]/gu, (char) => `-${char.toLowerCase()}`)}`).join(", ")}. It always starts fixed Market web/API surfaces; use \`trsd capacity ...\` for providers.`);
+      return fail(`\`trsd dev\` no longer accepts ${removedOptions.map((name) => `--${name.replace(/[A-Z]/gu, (char) => `-${char.toLowerCase()}`)}`).join(", ")}. It always starts fixed Market web/API/dev-runner surfaces; use \`trsd capacity ...\` for providers.`);
     }
     const feedback = typeof invocation.args.feedback === "string" ? invocation.args.feedback : void 0;
     const watch = feedback !== "off";

package/dist/cli/handlers/projects.js

@@ -1,47 +1,402 @@
-import { guidedResult } from "./utils.js";
+import { MarketApiError } from "@treeseed/sdk/market-client";
+import { fail, guidedResult } from "./utils.js";
 import { createMarketClientForInvocation } from "./market-utils.js";
+const DEPLOYMENT_TERMINAL_STATUSES = /* @__PURE__ */ new Set(["succeeded", "failed", "cancelled", "timed_out"]);
+const FORBIDDEN_OUTPUT_FIELDS = /* @__PURE__ */ new Set([
+  "capacityProviderId",
+  "laneId",
+  "grantId",
+  "workerPoolId",
+  "runtimeHostId",
+  "railwayServiceId",
+  "runnerToken"
+]);
+const ACTIONS = {
+  deploy: "deploy_web",
+  publish: "publish_content",
+  monitor: "monitor"
+};
+function stringArg(invocation, key) {
+  const value = invocation.args[key];
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function boolArg(invocation, key) {
+  return invocation.args[key] === true;
+}
+function environmentArg(invocation) {
+  const value = stringArg(invocation, "environment") ?? "staging";
+  return value === "prod" ? "prod" : "staging";
+}
+function projectUsage(action) {
+  switch (action) {
+    case "deploy":
+      return "Usage: treeseed projects deploy <project-id> --environment staging|prod";
+    case "publish":
+      return "Usage: treeseed projects publish <project-id> --environment staging|prod";
+    case "monitor":
+      return "Usage: treeseed projects monitor <project-id> --environment staging|prod";
+    case "deployments":
+      return "Usage: treeseed projects deployments <project-id>";
+    case "deployment":
+      return "Usage: treeseed projects deployment <project-id> <deployment-id>";
+    default:
+      return "Usage: treeseed projects [list|access|deploy|publish|monitor|deployments|deployment]";
+  }
+}
+function authFailure(error) {
+  if (error instanceof MarketApiError && [401, 403].includes(error.status)) {
+    return fail(error.message, 2);
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  if (/not logged in|unauthori[sz]ed|forbidden/iu.test(message)) {
+    return fail(message, 2);
+  }
+  return null;
+}
+function deploymentApiExitCode(error) {
+  if (error instanceof MarketApiError) {
+    if ([401, 403].includes(error.status)) return 2;
+    const payload = error.payload;
+    const code = payload?.error?.code ?? payload?.code;
+    if (code === "operation_not_retryable" || code === "operation_not_cancellable") return 1;
+  }
+  return 1;
+}
+function redact(value) {
+  if (Array.isArray(value)) return value.map((item) => redact(item));
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(Object.entries(value).filter(([key]) => !FORBIDDEN_OUTPUT_FIELDS.has(key)).filter(([key]) => !/(?:secret|token|password|apiKey|privateKey)/iu.test(key)).map(([key, entry]) => [key, redact(entry)]));
+}
+function text(value, fallback = "") {
+  return typeof value === "string" && value.trim() ? value.trim() : fallback;
+}
+function actionLabel(action) {
+  switch (action) {
+    case "deploy_web":
+      return "deploy_web";
+    case "publish_content":
+      return "publish_content";
+    case "monitor":
+      return "monitor";
+    default:
+      return text(action, "deployment");
+  }
+}
+function deploymentUrl(deployment) {
+  return text(deployment?.target?.url, text(deployment?.target?.previewUrl, ""));
+}
+function workflowUrl(deployment) {
+  return text(deployment?.externalWorkflow?.url, text(deployment?.externalWorkflow?.htmlUrl, text(deployment?.externalWorkflow?.runUrl, "")));
+}
+function inspectCommand(projectId, deploymentId) {
+  return `trsd projects deployment ${projectId} ${deploymentId}`;
+}
+function retryCommand(projectId, deploymentId) {
+  return `trsd projects deployment retry ${projectId} ${deploymentId}`;
+}
+function deploymentLine(deployment) {
+  return [
+    deployment.id,
+    deployment.environment,
+    actionLabel(deployment.action),
+    deployment.status,
+    deployment.monitor?.status ? `monitor=${deployment.monitor.status}` : "",
+    deployment.completedAt ?? deployment.finishedAt ?? deployment.updatedAt ?? "",
+    workflowUrl(deployment),
+    deploymentUrl(deployment)
+  ].filter(Boolean).join("  ");
+}
+function waitExitCode(status) {
+  if (status === "succeeded") return 0;
+  if (status === "timed_out") return 4;
+  if (status === "cancelled") return 5;
+  return 3;
+}
+function monitorExitCode(deployment, fallback) {
+  if (deployment?.monitor?.status === "failed") return 3;
+  if (["healthy", "degraded", "unknown"].includes(String(deployment?.monitor?.status))) return 0;
+  return fallback;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function waitForDeployment(input) {
+  const started = Date.now();
+  let current = (await input.client.projectDeployment(input.projectId, input.deploymentId)).payload;
+  while (!DEPLOYMENT_TERMINAL_STATUSES.has(String(current.status))) {
+    if (Date.now() - started >= input.timeoutSeconds * 1e3) {
+      return {
+        exitCode: 4,
+        deployment: current,
+        timedOut: true
+      };
+    }
+    await delay(input.pollIntervalMs);
+    current = (await input.client.projectDeployment(input.projectId, input.deploymentId)).payload;
+  }
+  return {
+    exitCode: waitExitCode(String(current.status)),
+    deployment: current,
+    timedOut: false
+  };
+}
+function timeoutSeconds(invocation) {
+  const value = Number(stringArg(invocation, "timeoutSeconds") ?? 300);
+  return Number.isFinite(value) && value > 0 ? value : 300;
+}
+function pollIntervalMs(invocation) {
+  const value = Number(stringArg(invocation, "pollIntervalMs") ?? 1e3);
+  return Number.isFinite(value) && value > 0 ? value : 1e3;
+}
+function deploymentRequestBody(invocation, action, environment) {
+  const body = {
+    environment,
+    action,
+    source: "cli"
+  };
+  const reason = stringArg(invocation, "reason");
+  const idempotencyKey = stringArg(invocation, "idempotencyKey");
+  if (boolArg(invocation, "dryRun")) body.dryRun = true;
+  if (reason) body.reason = reason;
+  if (idempotencyKey) body.idempotencyKey = idempotencyKey;
+  if (environment === "prod" && action !== "monitor") body.confirmProduction = true;
+  return body;
+}
+function monitorFacts(deployment) {
+  const monitor = deployment?.monitor && typeof deployment.monitor === "object" ? deployment.monitor : null;
+  if (!monitor) return [];
+  return [
+    { label: "Monitor", value: monitor.status ?? null },
+    { label: "Checked", value: monitor.checkedAt ?? null },
+    { label: "Checks", value: Array.isArray(monitor.checks) ? `${monitor.checks.filter((check) => check.status === "passed").length} passed, ${monitor.checks.filter((check) => check.status === "warning").length} warnings, ${monitor.checks.filter((check) => check.status === "failed").length} failed` : null }
+  ];
+}
+function monitorSection(deployment) {
+  const checks = Array.isArray(deployment?.monitor?.checks) ? deployment.monitor.checks : [];
+  if (checks.length === 0) return [];
+  return [{
+    title: "Monitor checks",
+    lines: checks.map((check) => [
+      check.status ?? "skipped",
+      check.key ?? check.label ?? "check",
+      check.summary ?? "",
+      check.inspectCommand ?? check.url ?? ""
+    ].filter(Boolean).join("  "))
+  }];
+}
 const handleProjects = async (invocation, context) => {
   const action = invocation.positionals[0] ?? "list";
-  const { profile, client } = createMarketClientForInvocation(invocation, context, { requireAuth: true });
-  if (action === "list") {
-    const teamId = typeof invocation.args.team === "string" ? invocation.args.team : null;
-    const response = await client.projects(teamId);
-    return guidedResult({
-      command: "projects",
-      summary: "Treeseed market projects",
-      sections: [{
-        title: "Projects",
-        lines: response.payload.map((project) => `${project.id}  ${project.name ?? project.slug}  team=${project.teamId}`)
-      }],
-      report: { marketId: profile.id, teamId, projects: response.payload }
-    });
+  let market;
+  try {
+    market = createMarketClientForInvocation(invocation, context, { requireAuth: true });
+  } catch (error) {
+    return authFailure(error) ?? fail(error instanceof Error ? error.message : String(error), 1);
   }
-  if (action === "access") {
-    const projectId = invocation.positionals[1];
-    if (!projectId) return { exitCode: 1, stderr: ["Usage: treeseed projects access <project-id>"] };
-    const response = await client.projectAccess(projectId);
+  const { profile, client } = market;
+  try {
+    if (action === "list") {
+      const teamId = typeof invocation.args.team === "string" ? invocation.args.team : null;
+      const response = await client.projects(teamId);
+      return guidedResult({
+        command: "projects",
+        summary: "Treeseed market projects",
+        sections: [{
+          title: "Projects",
+          lines: response.payload.map((project) => `${project.id}  ${project.name ?? project.slug}  team=${project.teamId}`)
+        }],
+        report: { marketId: profile.id, teamId, projects: redact(response.payload) }
+      });
+    }
+    if (action === "access") {
+      const projectId = invocation.positionals[1];
+      if (!projectId) return fail(projectUsage(action));
+      const response = await client.projectAccess(projectId);
+      return guidedResult({
+        command: "projects",
+        summary: "Treeseed market project access",
+        facts: [
+          { label: "Project", value: response.payload.projectId },
+          { label: "Staging admin", value: response.payload.team.summary.canAdminStaging },
+          { label: "Production admin", value: response.payload.team.summary.canAdminProduction }
+        ],
+        sections: [{
+          title: "Environments",
+          lines: response.payload.environments.map((entry) => `${entry.environment}: ${entry.role}`)
+        }],
+        report: { marketId: profile.id, access: redact(response.payload) }
+      });
+    }
+    if (action === "connect") {
+      return fail("Use treeseed config --connect-market --market-project-id <project-id> for project pairing.");
+    }
+    if (action in ACTIONS) {
+      const projectId = invocation.positionals[1];
+      if (!projectId) return fail(projectUsage(action));
+      const environment = environmentArg(invocation);
+      const deploymentAction = ACTIONS[action];
+      if (environment === "prod" && deploymentAction !== "monitor" && !boolArg(invocation, "yes")) {
+        return fail(`Production ${action} requires --yes and was not queued.`);
+      }
+      const response = await client.createProjectWebDeployment(projectId, deploymentRequestBody(invocation, deploymentAction, environment));
+      let deployment = response.deployment;
+      let waitResult = null;
+      if (boolArg(invocation, "wait")) {
+        waitResult = await waitForDeployment({
+          client,
+          projectId,
+          deploymentId: deployment.id,
+          timeoutSeconds: timeoutSeconds(invocation),
+          pollIntervalMs: pollIntervalMs(invocation)
+        });
+        deployment = waitResult.deployment;
+      }
+      const exitCode = monitorExitCode(deployment, waitResult?.exitCode ?? 0);
+      const summary = waitResult ? waitResult.timedOut ? "Treeseed project deployment wait timed out" : deployment.status === "succeeded" ? "Treeseed project deployment completed" : `Treeseed project deployment ${deployment.status}` : "Treeseed project deployment queued";
+      const nextSteps = [
+        inspectCommand(projectId, deployment.id),
+        ...["failed", "timed_out", "cancelled"].includes(deployment.status) ? [retryCommand(projectId, deployment.id)] : []
+      ];
+      return guidedResult({
+        command: "projects",
+        summary,
+        exitCode,
+        facts: [
+          { label: "Project", value: projectId },
+          { label: "Environment", value: deployment.environment },
+          { label: "Action", value: deployment.action },
+          { label: "Deployment", value: deployment.id },
+          { label: "Operation", value: deployment.platformOperationId ?? response.operation?.id ?? null },
+          { label: "Status", value: deployment.status },
+          { label: "URL", value: deploymentUrl(deployment) || null },
+          { label: "Workflow", value: workflowUrl(deployment) || null },
+          ...monitorFacts(deployment)
+        ],
+        sections: monitorSection(deployment),
+        nextSteps,
+        report: {
+          marketId: profile.id,
+          projectId,
+          deployment: redact(deployment),
+          operation: redact(response.operation),
+          pollUrl: response.pollUrl,
+          eventsUrl: response.eventsUrl,
+          stateUrl: response.stateUrl,
+          wait: waitResult ? { timedOut: waitResult.timedOut, exitCode } : null
+        }
+      });
+    }
+    if (action === "deployments") {
+      const projectId = invocation.positionals[1];
+      if (!projectId) return fail(projectUsage(action));
+      const response = await client.projectDeployments(projectId, {
+        environment: stringArg(invocation, "environment"),
+        limit: stringArg(invocation, "limit")
+      });
+      return guidedResult({
+        command: "projects",
+        summary: "Treeseed project deployments",
+        sections: [{
+          title: "Deployments",
+          lines: response.payload.map(deploymentLine)
+        }],
+        report: { marketId: profile.id, projectId, deployments: redact(response.payload) }
+      });
+    }
+    if (action === "deployment") {
+      const subaction = invocation.positionals[1];
+      const projectId = ["retry", "resume", "cancel"].includes(String(subaction)) ? invocation.positionals[2] : invocation.positionals[1];
+      const deploymentId = ["retry", "resume", "cancel"].includes(String(subaction)) ? invocation.positionals[3] : invocation.positionals[2];
+      if (!projectId || !deploymentId) return fail(projectUsage(action));
+      if (subaction === "retry") {
+        const response = await client.retryProjectDeployment(projectId, deploymentId, {
+          ...stringArg(invocation, "idempotencyKey") ? { idempotencyKey: stringArg(invocation, "idempotencyKey") } : {}
+        });
+        return guidedResult({
+          command: "projects",
+          summary: "Treeseed project deployment retry queued",
+          facts: [
+            { label: "Original deployment", value: response.originalDeployment.id },
+            { label: "Retry deployment", value: response.retryDeployment.id },
+            { label: "Operation", value: response.operation?.id ?? response.retryDeployment.platformOperationId },
+            { label: "Status", value: response.retryDeployment.status }
+          ],
+          nextSteps: [inspectCommand(projectId, response.retryDeployment.id)],
+          report: { marketId: profile.id, projectId, originalDeployment: redact(response.originalDeployment), retryDeployment: redact(response.retryDeployment), operation: redact(response.operation) }
+        });
+      }
+      if (subaction === "resume") {
+        try {
+          const response = await client.resumeProjectDeployment(projectId, deploymentId);
+          return guidedResult({
+            command: "projects",
+            summary: "Treeseed project deployment resume queued",
+            report: { marketId: profile.id, projectId, response: redact(response) }
+          });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          return guidedResult({
+            command: "projects",
+            summary: message,
+            exitCode: deploymentApiExitCode(error),
+            stderr: [message],
+            report: { marketId: profile.id, projectId, deploymentId, ok: false, error: message }
+          });
+        }
+      }
+      if (subaction === "cancel") {
+        const response = await client.cancelProjectDeployment(projectId, deploymentId);
+        const exitCode = response.deployment.status === "cancelled" ? 5 : 0;
+        return guidedResult({
+          command: "projects",
+          summary: response.deployment.status === "cancelled" ? "Treeseed project deployment cancelled" : "Treeseed project deployment cancellation requested",
+          exitCode,
+          facts: [
+            { label: "Deployment", value: response.deployment.id },
+            { label: "Status", value: response.deployment.status },
+            { label: "Cancellation", value: response.cancellation }
+          ],
+          report: { marketId: profile.id, projectId, deployment: redact(response.deployment), cancellation: response.cancellation }
+        });
+      }
+      const [deploymentResponse, eventsResponse] = await Promise.all([
+        client.projectDeployment(projectId, deploymentId),
+        client.projectDeploymentEvents(projectId, deploymentId)
+      ]);
+      const deployment = deploymentResponse.payload;
+      return guidedResult({
+        command: "projects",
+        summary: "Treeseed project deployment",
+        facts: [
+          { label: "Project", value: projectId },
+          { label: "Deployment", value: deployment.id },
+          { label: "Environment", value: deployment.environment },
+          { label: "Action", value: deployment.action },
+          { label: "Status", value: deployment.status },
+          { label: "URL", value: deploymentUrl(deployment) || null },
+          { label: "Workflow", value: workflowUrl(deployment) || null },
+          ...monitorFacts(deployment)
+        ],
+        sections: [{
+          title: "Events",
+          lines: eventsResponse.payload.map((event) => `${event.sequence}  ${event.kind}  ${event.status ?? ""}  ${event.message}`)
+        }, ...monitorSection(deployment)],
+        nextSteps: ["failed", "timed_out", "cancelled"].includes(deployment.status) ? [retryCommand(projectId, deployment.id)] : [],
+        report: { marketId: profile.id, projectId, deployment: redact(deployment), events: redact(eventsResponse.payload) }
+      });
+    }
+    return fail(`Unknown projects action: ${action}`);
+  } catch (error) {
+    const auth = authFailure(error);
+    if (auth) return auth;
+    const message = error instanceof Error ? error.message : String(error);
     return guidedResult({
       command: "projects",
-      summary: "Treeseed market project access",
-      facts: [
-        { label: "Project", value: response.payload.projectId },
-        { label: "Staging admin", value: response.payload.team.summary.canAdminStaging },
-        { label: "Production admin", value: response.payload.team.summary.canAdminProduction }
-      ],
-      sections: [{
-        title: "Environments",
-        lines: response.payload.environments.map((entry) => `${entry.environment}: ${entry.role}`)
-      }],
-      report: { marketId: profile.id, access: response.payload }
+      summary: message,
+      exitCode: deploymentApiExitCode(error),
+      stderr: [message],
+      report: { marketId: profile.id, ok: false, error: message }
     });
   }
-  if (action === "connect") {
-    return {
-      exitCode: 1,
-      stderr: ["Use treeseed config --connect-market --market-project-id <project-id> for project pairing."]
-    };
-  }
-  return { exitCode: 1, stderr: [`Unknown projects action: ${action}`] };
 };
 export {
   handleProjects

package/dist/cli/operations-registry.js

@@ -1168,29 +1168,30 @@ const CLI_COMMAND_OVERLAYS = /* @__PURE__ */ new Map([
     examples: ["treeseed dev", "treeseed dev --reset", "treeseed dev --reset --plan --json", "treeseed dev --web-runtime local --plan --json", "treeseed dev --port 4322"],
     help: {
       longSummary: [
-        "Dev starts the local Treeseed Market web/API runtime as a foreground supervisor.",
+        "Dev starts the local Treeseed Market web/API/runtime services as a foreground supervisor.",
         "Capacity provider lifecycle is package-owned and runs through `treeseed capacity ...`, not through `treeseed dev`."
       ],
       beforeYouRun: [
         "Run from the tenant or workspace root you want to develop.",
-        "Use `--plan --json` when you want to inspect fixed web/API commands, setup steps, readiness checks, watched paths, and restart policy without starting services.",
-        "Use `--reset` when you want a fresh local D1 database, Mailpit inbox, generated worker bundle, and Wrangler temp output without deleting configuration.",
+        "From the Market repo root, dev automatically starts the local Market API, managed local PostgreSQL, and Market operations runner alongside the web UI.",
+        "Use `--plan --json` when you want to inspect fixed web/API/runner commands, setup steps, readiness checks, watched paths, and restart policy without starting services.",
+        "Use `--reset` when you want a fresh local D1 database, Market PostgreSQL state, Mailpit inbox, generated worker bundle, and Wrangler temp output without deleting configuration.",
         "Dev prints the local web URL after readiness; it does not open a browser unless you pass `--open on` or `--open auto`.",
         "Keep the foreground process running while you test. Press Ctrl+C to stop the supervised stack and free the local ports."
       ],
       examples: [
-        example("treeseed dev", "Start local Market development", "Run web and API locally and keep supervising them in the foreground."),
-        example("treeseed dev --reset", "Start from a fresh local runtime", "Clear disposable local dev state, rerun setup and D1 migrations, then start the dev supervisor."),
+        example("treeseed dev", "Start local Market development", "Run web, API, managed PostgreSQL setup, and the Market operations runner locally."),
+        example("treeseed dev --reset", "Start from a fresh local runtime", "Clear disposable local dev state, rerun setup and database migrations, then start the dev supervisor."),
         example("treeseed dev --reset --plan --json", "Inspect reset actions", "Emit the reset, setup, readiness, command, and watch plan without deleting local state or starting services."),
         example("treeseed dev --plan --json", "Inspect the runtime plan", "Emit a structured plan with setup steps, commands, ports, URLs, readiness checks, and watch entries."),
-        example("treeseed dev --web-runtime local --plan --json", "Inspect local web runtime", "Plan fixed web/API startup using the local Astro web runtime."),
-        example("treeseed dev --port 4322", "Change the web port", "Start the fixed web/API runtime with the Astro UI on a specific port."),
+        example("treeseed dev --web-runtime local --plan --json", "Inspect local web runtime", "Plan fixed web/API/runner startup using the local Astro web runtime."),
+        example("treeseed dev --port 4322", "Change the web port", "Start the fixed web/API/runner runtime with the Astro UI on a specific port."),
         example("treeseed dev --open on", "Open the browser explicitly", "Start the integrated runtime and launch the local web URL after readiness."),
         example("trsd dev", "Use the short alias", "Start the same local runtime through the shorter entrypoint."),
         example("treeseed dev --json", "Stream dev events", "Emit newline-delimited events while the long-running dev process supervises local services.")
       ],
       outcomes: [
-        "Starts fixed local web/API surfaces, waits for readiness, prints the local URL, and then remains attached as the live supervisor.",
+        "Starts fixed local web/API/runner surfaces, waits for readiness, prints the local URL, and then remains attached as the live supervisor.",
         "Restarts required crashed surfaces with capped exponential backoff and keeps setup/readiness failures alive for retry.",
         "Stops watchers first and then terminates service process groups when the foreground command exits."
       ]
@@ -1495,23 +1496,44 @@ const CLI_ONLY_OPERATION_SPECS = [
     name: "projects",
     aliases: [],
     group: "Utilities",
-    summary: "Inspect projects and access controls from the selected market.",
-    description: "List market projects and inspect staging/production access through the market API client.",
+    summary: "Inspect projects and run web deployment operations from the selected market.",
+    description: "List market projects, inspect access, and queue or inspect project web deployment operations through the Market API.",
     provider: "default",
     related: ["market", "teams", "config"],
-    usage: "treeseed projects [list|access|connect]",
-    arguments: [{ name: "action", description: "Projects action.", required: false }],
+    usage: "treeseed projects [list|access|deploy|publish|monitor|deployments|deployment]",
+    arguments: [
+      { name: "action", description: "Projects action.", required: false },
+      { name: "project-id", description: "Project id for deployment and access actions.", required: false },
+      { name: "deployment-id", description: "Deployment id for deployment detail, retry, resume, or cancel.", required: false }
+    ],
     options: [
       { name: "market", flags: "--market <id-or-url>", description: "Select a configured market id or direct market API URL.", kind: "string" },
       { name: "team", flags: "--team <team-id>", description: "Limit project list to a team.", kind: "string" },
+      { name: "environment", flags: "--environment <environment>", description: "Deployment environment for project web actions.", kind: "enum", values: ["staging", "prod"] },
+      { name: "wait", flags: "--wait", description: "Poll the queued deployment until it reaches a terminal state.", kind: "boolean" },
+      { name: "timeoutSeconds", flags: "--timeout-seconds <seconds>", description: "Maximum seconds to wait before returning timeout.", kind: "string" },
+      { name: "pollIntervalMs", flags: "--poll-interval-ms <milliseconds>", description: "Polling interval for --wait.", kind: "string" },
+      { name: "dryRun", flags: "--dry-run", description: "Queue a dry-run deployment request when supported.", kind: "boolean" },
+      { name: "reason", flags: "--reason <text>", description: "Presentation-safe reason stored on the deployment request.", kind: "string" },
+      { name: "idempotencyKey", flags: "--idempotency-key <key>", description: "Deterministic idempotency key for the deployment request.", kind: "string" },
+      { name: "yes", flags: "--yes", description: "Required confirmation for production deploy and publish actions.", kind: "boolean" },
+      { name: "limit", flags: "--limit <count>", description: "Maximum number of deployments to list.", kind: "string" },
       { name: "json", flags: "--json", description: "Emit machine-readable JSON instead of human-readable text.", kind: "boolean" }
     ],
-    examples: ["treeseed projects list", "treeseed projects access project_123"],
+    examples: [
+      "treeseed projects list",
+      "treeseed projects access project_123",
+      "treeseed projects deploy project_123 --environment staging --wait",
+      "treeseed projects publish project_123 --environment prod --yes",
+      "treeseed projects deployments project_123 --json",
+      "treeseed projects deployment project_123 dep_123"
+    ],
     help: {
-      longSummary: ["Projects reads project and environment access data from the selected market API using the SDK market client."],
-      whenToUse: ["Use this to confirm which market projects you can see and whether your account has staging or production admin access."],
-      beforeYouRun: ["Authenticate to the market and know the project id when inspecting a single project access summary."],
-      automationNotes: ["Use `--json` to capture project lists and access summaries for automation."]
+      longSummary: ["Projects reads project, access, and deployment state from the selected market API using the SDK market client."],
+      whenToUse: ["Use this to inspect projects, queue staging or production web deployment operations, and inspect the same deployment state shown in the Market UI."],
+      beforeYouRun: ["Authenticate to the market with `treeseed auth:login --market <selector>` and know the project id before queueing deployment work."],
+      automationNotes: ["Use `--json` to capture project lists, deployment records, events, and wait results for automation."],
+      warnings: ["Production deploy and publish require `--yes`; without it the CLI exits before calling the API."]
     },
     helpVisible: true,
     helpFeatured: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeseed/cli",
-  "version": "0.10.6",
+  "version": "0.10.7",
   "description": "Operator-facing Treeseed CLI package.",
   "license": "AGPL-3.0-only",
   "repository": {
@@ -31,7 +31,7 @@
     "setup:ci": "npm ci",
     "build": "npm run build:dist",
     "lint": "npm run build:dist",
-    "test": "npm run build:dist && node --test --test-concurrency=1 ./scripts/treeseed-help.test.mjs ./scripts/seed.test.mjs ./scripts/wrapper-package.test.mjs",
+    "test": "npm run build:dist && node --test --test-concurrency=1 ./scripts/treeseed-help.test.mjs ./scripts/seed.test.mjs ./scripts/projects-deploy.test.mjs ./scripts/wrapper-package.test.mjs",
     "build:dist": "node ./scripts/run-ts.mjs ./scripts/build-dist.ts",
     "prepare": "node ./scripts/prepare.mjs",
     "prepack": "npm run build:dist",
@@ -45,7 +45,7 @@
     "release:publish": "node ./scripts/run-ts.mjs ./scripts/publish-package.ts"
   },
   "dependencies": {
-    "@treeseed/sdk": "github:treeseed-ai/sdk#0.10.12",
+    "@treeseed/sdk": "github:treeseed-ai/sdk#0.10.13",
     "ink": "^7.0.0",
     "react": "^19.2.5"
   },