@anyship/cli 0.4.0 → 0.5.0

package/README.md

@@ -43,12 +43,20 @@ stack, builds if needed, and returns a live URL.
 
 ```bash
 anyship deploy --project my-app .
+anyship deploy .                              # re-deploy — name read from .anyship/project.json
 anyship deploy --project my-app . --dry-run   # list what would be uploaded
 anyship status --project my-app --watch       # poll until deployed or failed
 ```
 
-Options: `--project <name>`, `--api <url>`, `--key <token>`, `--env <json>`,
-`--dry-run`, `--json`.
+On a successful deploy the CLI records the project name and its server-assigned
+stub (`slug`, `projectId`, `api`) in `<dir>/.anyship/project.json`. Later deploys
+of the same directory reuse that name automatically, so `--project` is optional
+once a directory has been deployed. The `.anyship/` directory is never uploaded
+(it's excluded from the archive); add it to `.gitignore` if you don't want it in
+version control.
+
+Options: `--project <name>` (optional when a manifest exists), `--api <url>`,
+`--key <token>`, `--env <json>`, `--dry-run`, `--json`.
 
 ### `anyship status --project <name>`
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anyship/cli",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "anyship CLI — deploy a local project directory, run a local MCP server for AI agents, and log in.",
   "type": "module",
   "bin": {

package/src/deploy-directory.mjs

@@ -5,11 +5,13 @@ import { homedir } from "node:os";
 import { basename, join, relative, resolve } from "node:path";
 import { zipSync } from "fflate";
 import { readAnyshipConfig } from "./config.mjs";
+import { manifestProjectName, writeProjectManifest } from "./project-manifest.mjs";
 
 export const DEFAULT_API = "https://drydock.anyship.workers.dev";
 
 export const EXCLUDED_DIRS = new Set([
   ".git",
+  ".anyship",
   ".codex",
   ".agents",
   ".wrangler",
@@ -29,7 +31,8 @@ export function deployUsage(commandName = "anyship deploy") {
   return `Usage: ${commandName} --project <name> [path]
 
 Options:
-  --project <name>   anyship project name
+  --project <name>   anyship project name (optional if the directory has a
+                     recorded .anyship/project.json from a previous deploy)
   --api <url>        control-plane URL (defaults to your MCP connector config, ANYSHIP_API_URL, or ${DEFAULT_API})
   --key <token>      anyship API key (defaults to ANYSHIP_API_KEY, ~/.anyship, or the key in your MCP connector config — ~/.codex/config.toml or ~/.claude.json)
   --env <json>       JSON object of env vars/secrets to merge for the project
@@ -82,7 +85,8 @@ export function parseDeployArgs(argv) {
     }
     throw new Error(`unknown argument: ${arg}`);
   }
-  if (!args.help && !args.project) throw new Error("--project is required");
+  // `--project` may be omitted when the target directory already has a recorded
+  // .anyship/project.json; deployDirectory resolves it against the manifest.
   return args;
 }
 
@@ -275,9 +279,17 @@ export async function buildZip(root) {
 
 export async function deployDirectory(args, hooks = {}) {
   const root = resolve(args.path ?? ".");
+  // Resolve the project name: explicit flag wins, else the name recorded for
+  // this directory on a previous deploy (.anyship/project.json).
+  const project = (args.project && args.project.trim()) || manifestProjectName(root);
+  if (!project) {
+    throw new Error(
+      "--project is required — pass it once and anyship records it in .anyship/project.json so later deploys of this directory don't need it.",
+    );
+  }
   const { zip, files, total } = await buildZip(root);
   const summary = {
-    project: args.project,
+    project,
     root,
     files,
     fileCount: files.length,
@@ -293,7 +305,7 @@ export async function deployDirectory(args, hooks = {}) {
   hooks.onUpload?.({ ...summary, api });
 
   const form = new FormData();
-  form.append("project", args.project);
+  form.append("project", project);
   if (args.env) form.append("env", args.env);
   form.append("file", new Blob([zip], { type: "application/zip" }), `${basename(root) || "source"}.zip`);
 
@@ -307,7 +319,17 @@ export async function deployDirectory(args, hooks = {}) {
   if (!res.ok) {
     throw new Error(apiErrorMessage(res.status, data, text));
   }
-  return { dryRun: false, ...summary, api, response: data ?? text };
+  // Record this directory → project mapping (name + server-assigned stub/slug)
+  // so future deploys of the same folder don't need --project. Best-effort.
+  const deployed = data && typeof data === "object" ? data.project : null;
+  const manifestPath = writeProjectManifest(root, {
+    project,
+    projectId: deployed?.id,
+    slug: deployed?.slug,
+    api,
+    lastDeployedAt: new Date().toISOString(),
+  });
+  return { dryRun: false, ...summary, api, manifestPath, response: data ?? text };
 }
 
 export function apiErrorMessage(status, data, text = "") {

package/src/mcp-server.mjs

@@ -85,8 +85,9 @@ async function remoteProxy(method, params, deps) {
 }
 
 async function localDeploy(args, deps) {
+  // `project` may be omitted when the directory has a recorded
+  // .anyship/project.json — deployDirectory resolves it against the manifest.
   const project = String(args?.project ?? "").trim();
-  if (!project) throw new Error("`project` is required");
   const path = typeof args?.path === "string" && args.path.trim() ? args.path : ".";
   const env =
     args?.env && typeof args.env === "object" && !Array.isArray(args.env)
@@ -95,10 +96,11 @@ async function localDeploy(args, deps) {
   const runDeploy = deps.deployDirectory ?? deployDirectory;
   const result = await runDeploy({ project, path, env }, { interactive: false });
   const root = resolve(path);
+  const resolvedProject = result?.project ?? project;
   const message = result?.response?.message ?? "Deploying. Poll deployment_status for progress.";
   const depId = result?.response?.deployment?.id;
   return (
-    `🚧 Uploaded ${result.fileCount} file${result.fileCount === 1 ? "" : "s"} from ${root} for "${project}"` +
+    `🚧 Uploaded ${result.fileCount} file${result.fileCount === 1 ? "" : "s"} from ${root} for "${resolvedProject}"` +
     `${depId ? ` (deployment ${depId})` : ""}.\n${message}`
   );
 }

package/src/project-manifest.mjs

@@ -0,0 +1,52 @@
+// Per-directory deploy record: `<project-root>/.anyship/project.json`. Written
+// on a successful deploy and read on the next one so re-deploying a known folder
+// doesn't need the project name re-supplied — the same (account, name) pair that
+// the control plane keys re-deploys on is remembered locally. The `.anyship`
+// directory is in EXCLUDED_DIRS, so this file is never uploaded in the archive.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+export function manifestDir(root) {
+  return join(root, ".anyship");
+}
+
+export function manifestPath(root) {
+  return join(manifestDir(root), "project.json");
+}
+
+// Returns the stored record, or {} when there's no manifest / it's unreadable.
+export function readProjectManifest(root) {
+  try {
+    const parsed = JSON.parse(readFileSync(manifestPath(root), "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+// The project name recorded for this directory, if any.
+export function manifestProjectName(root) {
+  const name = readProjectManifest(root).project;
+  return typeof name === "string" && name.trim() ? name.trim() : "";
+}
+
+// Merge-write so fields we don't set (e.g. a url filled in later) survive.
+// Best-effort: a failure to record the manifest must never fail the deploy.
+export function writeProjectManifest(root, patch) {
+  try {
+    const dir = manifestDir(root);
+    mkdirSync(dir, { recursive: true });
+    const merged = { ...readProjectManifest(root), ...patch };
+    for (const key of Object.keys(merged)) {
+      if (merged[key] == null) delete merged[key];
+    }
+    writeFileSync(manifestPath(root), `${JSON.stringify(merged, null, 2)}\n`);
+    return manifestPath(root);
+  } catch {
+    return null;
+  }
+}
+
+export function manifestExists(root) {
+  return existsSync(manifestPath(root));
+}