@kryd/cli 0.8.1 → 0.9.0

package/README.md

@@ -20,6 +20,7 @@ kryd init                     # link this folder to a Kryd project (+ a `kryd` g
 kryd push                     # push the current branch → build → deploy → live, with live progress
 kryd logs                     # the full build log of the latest deploy (kryd push shows progress, not log lines)
 kryd logs <project> --runtime # tail the live app's stdout/stderr
+kryd logs <project> --worker  # tail the workflow worker's stdout/stderr
 ```
 
 Once you've run `kryd init` in a directory, the commands below work **arg-less** there — the folder is linked via `.kryd/project.json` (git-ignored, no secret).
@@ -32,7 +33,7 @@ Once you've run `kryd init` in a directory, the commands below work **arg-less**
 | `kryd init` | Link the current repo to a Kryd project + register the deploy webhook + add a `kryd` git remote. |
 | `kryd push [branch]` | Push to the `kryd` remote and follow the deploy it triggers (defaults to the current branch). Shows which step the deploy is on, how long it has taken and a progress bar; `--logs` streams the full build log instead. |
 | `kryd deploy [project]` | Re-deploy the production-branch HEAD already on the forge — no new commit. |
-| `kryd logs [target]` | Follow a deploy's build/deploy log **in full** — this is where the build output lives (`--runtime` tails the live container instead). |
+| `kryd logs [target]` | Follow a deploy's build/deploy log **in full** — this is where the build output lives (`--runtime` tails the live container instead; `--worker` tails the project's workflow worker, also when it has a web app). |
 | `kryd rollback [project] [deployment]` | Roll back to a previous successful deploy — no rebuild. |
 | `kryd db add \| remove \| status [project]` | Attach, tear down or inspect managed Postgres (shared or bring-your-own). `remove` destroys the data and asks first. |
 | `kryd storage add \| remove \| status [project]` | Attach, tear down or inspect S3-compatible object storage. `remove` destroys every object and asks first. |

package/dist/index.js

@@ -56,6 +56,7 @@ function parseDeployEvent(payload) {
 }
 
 // ../../packages/shared-types/dist/runtime-log.js
+var RUNTIME_REFUSAL_CODES = ["no-runtime", "pending"];
 function parseRuntimeStreamFrame(payload) {
   let parsed;
   try {
@@ -67,7 +68,8 @@ function parseRuntimeStreamFrame(payload) {
     return null;
   const e = parsed;
   if (e.kind === "error" && typeof e.message === "string") {
-    return { kind: "error", message: e.message };
+    const code = RUNTIME_REFUSAL_CODES.includes(e.code) ? e.code : void 0;
+    return code ? { kind: "error", message: e.message, code } : { kind: "error", message: e.message };
   }
   if (e.kind !== "runtime" || e.stream !== "stdout" && e.stream !== "stderr" || typeof e.line !== "string") {
     return null;
@@ -14902,6 +14904,7 @@ function isTerminalResourceStatus(status) {
 import {
   existsSync as existsSync3,
   mkdirSync as mkdirSync2,
+  readFileSync as readFileSync3,
   realpathSync,
   rmSync as rmSync2,
   writeFileSync as writeFileSync2
@@ -15874,13 +15877,13 @@ async function streamDeploy(apiUrl, token, deploymentId, handlers, opts = {}) {
   return terminal;
 }
 async function streamRuntime(apiUrl, token, id, handlers, opts = {}) {
-  const basePath = opts.resource === "deployment" ? "deployments" : "projects";
+  const path = opts.resource === "deployment" ? `deployments/${id}/runtime-logs` : opts.resource === "worker" ? `projects/${id}/workflow-logs` : `projects/${id}/runtime-logs`;
   const doFetch = opts.fetchImpl ?? fetch;
   const reconnectMs = opts.reconnectMs ?? 1e3;
   let afterNs;
   while (!opts.signal?.aborted) {
     try {
-      const url2 = new URL(`${apiUrl}/${basePath}/${id}/runtime-logs`);
+      const url2 = new URL(`${apiUrl}/${path}`);
       if (afterNs) url2.searchParams.set("after", afterNs);
       else if (opts.since) url2.searchParams.set("since", opts.since);
       const res = await doFetch(url2, {
@@ -15988,7 +15991,13 @@ function isFramework(value) {
   return FRAMEWORKS.includes(value);
 }
 var DECLARATION_FILE = "kryd.json";
-var DECLARATION_KIND_WORKFLOW = "workflow";
+var DEFAULT_WORKFLOWS_PATH = "workflows";
+function declarationJson(decl) {
+  return {
+    ...decl.web ? {} : { web: false },
+    ...decl.workflowsPath !== null ? { workflows: { path: decl.workflowsPath } } : {}
+  };
+}
 var VITE_META_FRAMEWORKS = [
   "@sveltejs/kit",
   "astro",
@@ -16030,22 +16039,26 @@ function readPackageJson(cwd) {
     return null;
   }
 }
-function declaredKind(cwd) {
+function readDeclaration(cwd) {
+  let parsed;
   try {
-    const parsed = JSON.parse(
-      readFileSync2(join2(cwd, DECLARATION_FILE), "utf8")
-    );
-    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      return null;
-    }
-    const kind = parsed.kind;
-    return typeof kind === "string" ? kind : null;
+    parsed = JSON.parse(readFileSync2(join2(cwd, DECLARATION_FILE), "utf8"));
   } catch {
     return null;
   }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return null;
+  }
+  const decl = parsed;
+  const workflows = decl.workflows;
+  const workflowsPath = workflows && typeof workflows === "object" && typeof workflows.path === "string" ? workflows.path : null;
+  return { web: decl.web !== false, workflowsPath };
 }
 function frameworkFrom(pkg, cwd) {
-  if (declaredKind(cwd) === DECLARATION_KIND_WORKFLOW) return "workflow";
+  const declaration = readDeclaration(cwd);
+  if (declaration && !declaration.web && declaration.workflowsPath !== null) {
+    return "workflow";
+  }
   const deps = { ...pkg?.dependencies, ...pkg?.devDependencies };
   const has = (name) => name in deps;
   if (has("next")) return "nextjs";
@@ -16140,6 +16153,10 @@ export const hatchet = HatchetClient.init();
  * One task, to prove the wiring end to end. Add your own beside it and list them in
  * \`src/worker.ts\` \u2014 everything about how a task runs (retries, timeouts, concurrency, crons,
  * DAGs) belongs to the engine's SDK, not to Kryd.
+ *
+ * A task can be cut off by a deploy or a restart: measured, a TypeScript worker stops within seconds
+ * and the engine runs the task again from the start on another worker ~30 s later, even with
+ * \`retries: 0\` \u2014 so write every task so that running it again is safe.
  */
 export const greet = hatchet.task({
   name: "greet",
@@ -16188,7 +16205,15 @@ async function main(): Promise<void> {
   const { hatchet } = await import("./hatchet");
   const { greet } = await import("./tasks");
 
-  const worker = await hatchet.worker(WORKER_NAME, { workflows: [greet] });
+  // Kryd sets KRYD_DEPLOYMENT_ID on a deployed worker, and the label is how its deploy gate tells
+  // THIS deploy's worker from the previous one, which keeps running while it drains. Keep the line:
+  // the gate requires it, and a worker without it never counts as this deploy's, so the deploy
+  // never goes live. Locally the variable is absent, so no label.
+  const deployId = process.env.KRYD_DEPLOYMENT_ID;
+  const worker = await hatchet.worker(WORKER_NAME, {
+    workflows: [greet],
+    labels: deployId ? { "kryd-deploy": deployId } : undefined,
+  });
 
   // start() resolves when the worker stops, so it is not awaited here; waitUntilReady() flips the
   // health flag once the engine has the worker. A failed registration rejects \`running\` and the
@@ -16254,6 +16279,11 @@ from hatchet_sdk import Context, EmptyModel
 # One task, to prove the wiring end to end. Add your own beside it and list them in main.py \u2014
 # everything about how a task runs (retries, timeouts, concurrency, crons, DAGs) belongs to the
 # engine's SDK, not to Kryd.
+#
+# A task can be cut off by a deploy or a restart: a Python worker finishes a running task before it
+# stops (measured with 33 s left), but the stop has a 90 s grace period, and a task still running
+# after it is killed and run again from the start on another worker, even with retries=0 (measured)
+# \u2014 so write every task so that running it again is safe.
 @hatchet.task(name="greet")
 def greet(input: EmptyModel, ctx: Context) -> dict[str, str]:
     return {"greeting": "Hello, world"}
@@ -16430,6 +16460,11 @@ type GreetOutput struct {
 // Greet is one task, to prove the wiring end to end. Add your own beside it and register them in
 // main.go \u2014 everything about how a task runs (retries, timeouts, concurrency, crons, DAGs) belongs
 // to the engine's SDK, not to Kryd.
+//
+// A task can be cut off by a deploy or a restart: measured, a Go worker exits within a second of the
+// stop signal without waiting for running tasks, and the engine runs the task again from the start
+// on another worker ~30 s later, even with retries set to 0 \u2014 so write every task so that running it
+// again is safe.
 func Greet(c *hatchet.Client) *hatchet.StandaloneTask {
 	return c.NewStandaloneTask("greet", func(ctx hatchet.Context, input GreetInput) (GreetOutput, error) {
 		name := input.Name
@@ -16512,7 +16547,15 @@ func main() {
 		log.Fatalf("could not create the Hatchet client: %v", err)
 	}
 
-	worker, err := client.NewWorker(workerName, hatchet.WithWorkflows(Greet(client)))
+	// Kryd sets KRYD_DEPLOYMENT_ID on a deployed worker, and the label is how its deploy gate tells
+	// THIS deploy's worker from the previous one, which keeps running while it drains. Keep it:
+	// the gate requires it, and a worker without it never counts as this deploy's, so the deploy
+	// never goes live. Locally the variable is absent, so no label.
+	opts := []hatchet.WorkerOption{hatchet.WithWorkflows(Greet(client))}
+	if deployID := os.Getenv("KRYD_DEPLOYMENT_ID"); deployID != "" {
+		opts = append(opts, hatchet.WithLabels(map[string]any{"kryd-deploy": deployID}))
+	}
+	worker, err := client.NewWorker(workerName, opts...)
 	if err != nil {
 		log.Fatalf("could not create the worker: %v", err)
 	}
@@ -16571,15 +16614,19 @@ var TEMPLATES = {
   python: PYTHON_TEMPLATE,
   go: GO_TEMPLATE
 };
-function declarationFile() {
+function declarationFile(decl) {
   return {
     path: DECLARATION_FILE,
-    contents: `${JSON.stringify({ kind: DECLARATION_KIND_WORKFLOW }, null, 2)}
+    contents: `${JSON.stringify(declarationJson(decl), null, 2)}
 `
   };
 }
+var WORKER_ONLY = { web: false, workflowsPath: "." };
+function workerFiles(language, workerName) {
+  return TEMPLATES[language].files(workerName);
+}
 function scaffoldFiles(language, workerName) {
-  return [...TEMPLATES[language].files(workerName), declarationFile()];
+  return [...workerFiles(language, workerName), declarationFile(WORKER_ONLY)];
 }
 function firstCommand(language) {
   return TEMPLATES[language].firstCommand;
@@ -17313,11 +17360,14 @@ Install git (https://git-scm.com/downloads), then re-run \`kryd init\` here.
 `;
         break;
     }
-    const routing = project2.framework === "workflow" ? `No public URL: a workflow worker dials out to the engine and serves nothing.
+    const declaration = readDeclaration(cwd);
+    const workerOnly = declaration !== null ? !declaration.web && declaration.workflowsPath !== null : project2.framework === "workflow";
+    const routing = workerOnly ? `No public URL: a workflow worker dials out to the engine and serves nothing.
 Scheduled and triggered work runs on your production deploy; preview branches build but do not start a worker.
 ` : `Production URL: https://${project2.subdomain}.${PRODUCTION_TLD}
 Preview branches deploy to https://<branch>-<hash>-${project2.subdomain}.${PREVIEW_TLD}
-`;
+` + (declaration?.workflowsPath ? `Workflows in ${declaration.workflowsPath}/ run as a worker beside it on production deploys; previews run the web app only.
+` : "");
     process.stdout.write(
       `Linked "${name}" (${project2.framework}) \u2192 ${repo.htmlUrl}
 ` + routing + `${linkNote}
@@ -17452,9 +17502,16 @@ async function runRuntimeLogs(opts) {
     return;
   }
   const isDeployment = opts.project?.startsWith("dpl_") ?? false;
+  if (opts.worker && isDeployment) {
+    process.stderr.write(
+      "--worker takes a project, not a deployment id: use `kryd logs <project> --worker` to follow the project's worker.\n"
+    );
+    process.exitCode = 1;
+    return;
+  }
   const target = isDeployment ? opts.project : resolveProjectId(opts.project, opts.cwd);
   if (!target) {
-    reportNotLinked("kryd logs <projectId> --runtime");
+    reportNotLinked(opts.worker ? "kryd logs <projectId> --worker" : "kryd logs <projectId> --runtime");
     return;
   }
   if (opts.since !== void 0 && !/^\d+(s|m|h|d)$/.test(opts.since.trim())) {
@@ -17483,7 +17540,7 @@ async function runRuntimeLogs(opts) {
       {
         ...opts.since ? { since: opts.since } : {},
         signal: controller.signal,
-        ...isDeployment ? { resource: "deployment" } : {}
+        ...isDeployment ? { resource: "deployment" } : opts.worker ? { resource: "worker" } : {}
       }
     );
   } catch (err) {
@@ -18346,6 +18403,22 @@ async function runWorkflowInit(opts) {
   }
   const language = opts.language;
   const target = opts.dir ? resolve2(cwd, opts.dir) : cwd;
+  if (!opts.only) {
+    scaffoldContainedWorker({
+      language,
+      target,
+      ...opts.path !== void 0 ? { path: opts.path } : {},
+      ...opts.name !== void 0 ? { name: opts.name } : {}
+    });
+    return;
+  }
+  if (opts.path !== void 0) {
+    process.stderr.write(
+      "--path is for a worker inside an app; with --only the worker IS the repository root.\n"
+    );
+    process.exitCode = 1;
+    return;
+  }
   const workerName = workerNameFrom(opts.name ?? basename2(target));
   const files = scaffoldFiles(language, workerName);
   const clashes = files.map((f) => f.path).filter((p) => existsSync3(join3(target, p)));
@@ -18391,9 +18464,10 @@ Nothing was left behind.
   if (repo.status === "nested") {
     process.stderr.write(
       `That directory is inside the git repository at ${repo.root}.
-A worker has to be its own repository: Kryd builds one app per repository, and git would
-write the deploy remote into the enclosing repo, so \`kryd push\` would push that tree instead.
+A worker-only project (--only) has to be its own repository: git would write the deploy
+remote into the enclosing repo, so \`kryd push\` would push that tree instead.
 The files above were written \u2014 move them to a directory of their own, or run this outside that repository.
+To add a worker to the app in that repository instead, run \`kryd workflow init\` (without --only) at its root.
 `
     );
     process.exitCode = 1;
@@ -18440,6 +18514,131 @@ HATCHET_CLIENT_TOKEN is injected into your container on deploy; it is never avai
 `
   );
 }
+function scaffoldContainedWorker(opts) {
+  const { language, target } = opts;
+  if (!directoryIsLinked(target)) {
+    process.stderr.write(
+      "This directory is not linked to a Kryd project, so there is no app to add a worker to.\nLink your app first (`kryd init`), then run this again \u2014 or pass --only for a project that runs nothing but a worker.\n"
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const raw = (opts.path ?? DEFAULT_WORKFLOWS_PATH).trim();
+  const segments = raw.split("/").filter((seg) => seg !== "" && seg !== ".");
+  if (raw.startsWith("/") || raw.includes("\\") || segments.includes("..") || segments.length === 0) {
+    process.stderr.write(
+      `--path must be a folder inside this project (e.g. "${DEFAULT_WORKFLOWS_PATH}"), not "${raw}". For a worker at the repository root, use --only in a directory of its own.
+`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const folder = segments.join("/");
+  const declarationPath = join3(target, DECLARATION_FILE);
+  let existing = {};
+  let existingText = null;
+  if (existsSync3(declarationPath)) {
+    existingText = readFileSync3(declarationPath, "utf8");
+    let parsed;
+    try {
+      parsed = JSON.parse(existingText);
+    } catch {
+      parsed = void 0;
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      process.stderr.write(
+        `${DECLARATION_FILE} is not a JSON object, so a worker cannot be added to it. Fix or remove it, then run this again.
+`
+      );
+      process.exitCode = 1;
+      return;
+    }
+    existing = parsed;
+    if ("kind" in existing) {
+      process.stderr.write(
+        `${DECLARATION_FILE} still uses \`{"kind":"workflow"}\`, which is no longer read. A worker-only repository is \`{"web": false, "workflows": {"path": "."}}\`; an app with workflows in a folder is \`{"workflows": {"path": "workflows"}}\`. Update it, then run this again if you still want a worker folder. Nothing was written.
+`
+      );
+      process.exitCode = 1;
+      return;
+    }
+    if ("workflows" in existing || existing["web"] === false) {
+      process.stderr.write(
+        `${DECLARATION_FILE} already declares a worker for this project \u2014 a project has one. Nothing was written.
+`
+      );
+      process.exitCode = 1;
+      return;
+    }
+  }
+  const workerName = workerNameFrom(opts.name ?? basename2(target));
+  const files = workerFiles(language, workerName).map((f) => ({
+    path: `${folder}/${f.path}`,
+    contents: f.contents
+  }));
+  const clashes = files.map((f) => f.path).filter((p) => existsSync3(join3(target, p)));
+  if (clashes.length > 0) {
+    process.stderr.write(
+      `Refusing to overwrite: ${clashes.join(", ")}.
+Nothing was written. Pick another folder with --path <folder>.
+`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const declaration = { ...existing, workflows: { path: folder } };
+  const written = [];
+  try {
+    for (const file2 of files) {
+      const full = join3(target, file2.path);
+      mkdirSync2(dirname2(full), { recursive: true });
+      writeFileSync2(full, file2.contents);
+      written.push(full);
+    }
+    writeFileSync2(declarationPath, `${JSON.stringify(declaration, null, 2)}
+`);
+  } catch (err) {
+    for (const path of written.reverse()) {
+      try {
+        rmSync2(path);
+      } catch {
+      }
+    }
+    try {
+      if (existingText === null) rmSync2(declarationPath, { force: true });
+      else writeFileSync2(declarationPath, existingText);
+    } catch {
+    }
+    process.stderr.write(
+      `Could not write the scaffold (${err instanceof Error ? err.message : String(err)}).
+Nothing was left behind.
+`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const next = [];
+  const first = firstCommand(language);
+  if (first) next.push(`(cd ${folder} && ${first})`);
+  next.push(
+    "kryd workflow add",
+    `git add ${DECLARATION_FILE} ${folder} && git commit -m "add workflows"`,
+    "kryd push"
+  );
+  process.stdout.write(
+    `Scaffolded a ${language} workflow worker in ${folder}/:
+` + files.map((f) => `  ${f.path}
+`).join("") + `and declared it in ${DECLARATION_FILE}: ${JSON.stringify({ workflows: { path: folder } })}
+
+Every production push now builds your app AND this worker, and goes live only when both are healthy. Previews run the app only.
+Next: ${next.map((c) => `\`${c}\``).join(", then ")}.
+HATCHET_CLIENT_TOKEN is injected into your app and your worker on deploy \u2014 your app triggers tasks with it; it is never available locally.
+` + // The app is still built (and type-checked) from the root, so a tsconfig that includes every
+    // file would compile the worker too — against an SDK the app does not depend on.
+    (existsSync3(join3(target, "tsconfig.json")) ? `Add "${folder}" to the "exclude" of your tsconfig.json, so your app's build does not type-check the worker.
+` : "")
+  );
+}
 async function runStorageRemove(opts) {
   const apiUrl = resolveApiUrl(opts.apiUrl);
   const token = loadConfig().token;
@@ -18926,7 +19125,7 @@ Run \`kryd env list\` to see what is set. (If you meant the runtime variable of
     await reportError(err);
   }
 }
-var CLI_VERSION = true ? "0.8.1" : "0.0.0-dev";
+var CLI_VERSION = true ? "0.9.0" : "0.0.0-dev";
 var program = new Command();
 program.name("kryd").description("Kryd CLI").version(CLI_VERSION);
 program.hook("postAction", async () => {
@@ -18948,7 +19147,7 @@ program.command("git-credential <operation>", { hidden: true }).description("git
 });
 program.command("init").description("Link this project's repo + register its push webhook").option("--name <name>", "project name (defaults to package.json name / dir)").option(
   "--framework <framework>",
-  "react-router | nextjs | vite-spa | node (auto-detected if omitted; `workflow` comes from a committed kryd.json)"
+  'react-router | nextjs | vite-spa | node (auto-detected if omitted; `workflow` comes from a committed kryd.json with "web": false)'
 ).option(
   "--tenant <slug>",
   // KRYD-265 / KRYD-188: this used to say "claimed once on first init", which was false — signup
@@ -18961,15 +19160,23 @@ program.command("init").description("Link this project's repo + register its pus
   "create the repository PUBLIC \u2014 readable by anyone signed in to the forge (default: private). Set at creation only"
 ).option("--api-url <url>", "control-plane API base URL").action((opts) => runInit(opts));
 program.command("logs [target]").description(
-  "Follow logs. Default: a deploy's build/deploy logs ([target]=deployment id, latest if omitted). With --runtime: a container's stdout/stderr \u2014 [target]=a project id tails its live app, a deployment id (dpl_\u2026) tails THAT deploy's container (incl. a failed one, to see why it crashed)."
+  "Follow logs. Default: a deploy's build/deploy logs ([target]=deployment id, latest if omitted). With --runtime: a container's stdout/stderr \u2014 [target]=a project id tails its live app, a deployment id (dpl_\u2026) tails THAT deploy's container (incl. a failed one, to see why it crashed). With --worker: a project's workflow worker, also when the project has a web app."
 ).option(
   "--runtime",
   "stream a container's runtime stdout/stderr instead of build/deploy logs \u2014 the live app (project id) or one deploy's container (dpl_ id)"
+).option(
+  "--worker",
+  "with a project id: stream its workflow WORKER's stdout/stderr (implies --runtime) \u2014 for a project with a web app too, --runtime shows the web app"
 ).option(
   "--since <dur>",
-  "with --runtime: backfill this window before going live (e.g. 30m, 2h, 1d; max 7d)"
+  "with --runtime/--worker: backfill this window before going live (e.g. 30m, 2h, 1d; max 7d)"
 ).option("--api-url <url>", "control-plane API base URL").action(
-  (target, opts) => opts.runtime ? runRuntimeLogs({ project: target, since: opts.since, apiUrl: opts.apiUrl }) : runLogs({ apiUrl: opts.apiUrl, deployment: target })
+  (target, opts) => opts.runtime || opts.worker ? runRuntimeLogs({
+    project: target,
+    since: opts.since,
+    apiUrl: opts.apiUrl,
+    ...opts.worker ? { worker: true } : {}
+  }) : runLogs({ apiUrl: opts.apiUrl, deployment: target })
 );
 program.command("push [branch]").description(
   "Push to the kryd remote and follow the deploy it triggers (defaults to the current branch)"
@@ -19038,11 +19245,11 @@ workflow.command("add [project]").description("Give the project a workflow tenan
 workflow.command("remove [project]").description("Revoke the project's workflow token and stop injecting it (asks for confirmation)").option("--yes", "skip the confirmation prompt").option("--api-url <url>", "control-plane API base URL").action((project2, opts) => runWorkflowRemove({ ...opts, project: project2 }));
 workflow.command("status [project]").description("Show whether the project has workflows, and when its token expires").option("--api-url <url>", "control-plane API base URL").action((project2, opts) => runWorkflowStatus({ ...opts, project: project2 }));
 workflow.command("init").description(
-  "Scaffold a workflow worker here (with the health listener Kryd's deploy gate needs) and link it"
+  "Add a workflow worker to the linked app here (in ./workflows, declared in kryd.json); --only scaffolds a worker-only project instead and links it"
 ).requiredOption(
   "--language <language>",
   `worker language: ${SCAFFOLD_LANGUAGES.join(" | ")}`
-).option("--dir <path>", "write into this directory instead of the current one").option("--name <name>", "project and worker name (defaults to the directory name)").option("--no-link", "only write the files; do not create a Kryd project").option("--api-url <url>", "control-plane API base URL").action((opts) => runWorkflowInit(opts));
+).option("--path <folder>", "the worker's folder inside the app (default: workflows)").option("--only", "a project that runs ONLY a worker: scaffold it at the root, git init, and link").option("--dir <path>", "the project directory, instead of the current one").option("--name <name>", "worker name (and, with --only, project name); defaults to the directory name").option("--no-link", "with --only: only write the files; do not create a Kryd project").option("--api-url <url>", "control-plane API base URL").action((opts) => runWorkflowInit(opts));
 function invokedDirectly() {
   const entry = process.argv[1];
   if (!entry) return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kryd/cli",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "description": "Kryd CLI — push a React / Vite / Next.js app to the European cloud for your AI: git push → live with SSL, one-click managed Postgres & object storage, and an EU-hosted AI gateway already wired in. Your code and your model calls stay in the EU.",
   "keywords": [
     "kryd",
@@ -50,8 +50,8 @@
     "typescript": "^5.6.3",
     "vitest": "^2.1.8",
     "@kryd/shared-types": "0.0.0",
-    "@kryd/config-ts": "0.0.0",
-    "@kryd/config-eslint": "0.0.0"
+    "@kryd/config-eslint": "0.0.0",
+    "@kryd/config-ts": "0.0.0"
   },
   "scripts": {
     "build": "esbuild src/index.ts --bundle --platform=node --format=esm --external:commander --define:__KRYD_VERSION__=\\\"$npm_package_version\\\" --outfile=dist/index.js",