@keystrokehq/cli 0.1.38 → 0.2.0

package/dist/skills-bundle/skills/keystroke-workflows/references/authoring.md

@@ -0,0 +1,168 @@
+# Workflow authoring
+
+## Keep steps in actions (when they are not agent prompts)
+
+Workflow `run` orchestrates — call actions for deterministic logic and integrations, call agents directly for LLM steps:
+
+```ts
+async run(input) {
+  const { brief } = await researchSignup.run(input);
+  const summary = await support.prompt({
+    message: `Summarize signup research:\n${brief}`,
+  });
+  const sent = await slackSendMessage.run({
+    channel: "#pipeline",
+    markdown_text: signupBriefMessage({ ...input, brief }),
+  });
+  return { brief, ...sent };
+}
+```
+
+Actions are leaf units: an action never calls another action — compose them in the workflow. Need formatting or shared logic between steps? Put it in `src/lib/`, not in a wrapper action.
+
+## Agents as workflow steps
+
+Import the agent and call `.prompt()` directly in the workflow `run`. Each call is a durable step keyed as `step:<agent-slug>#<occurrence>` (same scheme as actions). No wrapper action required when the step is just "prompt this agent."
+
+```ts
+const result = await support.prompt({
+  message: `From: ${input.sender}\nSubject: ${input.latestSubject}`,
+});
+```
+
+Use a wrapper action only when the agent call should also be an agent tool, or when the step bundles non-prompt logic.
+
+For an explicit step id, actions chain `.stepId("x")`; agent prompts take it as an option: `agent.prompt(input, { stepId: "x" })`.
+
+## LLM steps (`promptLlm`)
+
+For a one-shot LLM call without a full agent, use `promptLlm` (from `@keystrokehq/keystroke/workflow`). It's a first-class durable step keyed `step:promptLlm#<occurrence>`. The signature is `promptLlm(prompt, opts)` — the prompt string comes **first**, options second:
+
+```ts
+import { promptLlm } from "@keystrokehq/keystroke/workflow";
+
+// Returns a string when no outputSchema is given:
+const summary = await promptLlm(`Summarize:\n${brief}`, {
+  model: "anthropic/claude-sonnet-4.6",
+});
+```
+
+Pass `outputSchema` (Zod) to get a parsed, schema-validated object back instead of a string — the return type is inferred from the schema:
+
+```ts
+import { z } from "zod";
+
+const Category = z.object({ category: z.enum(["bug", "feature", "question"]) });
+
+const { category } = await promptLlm(`Classify this ticket:\n${ticket}`, {
+  model: "anthropic/claude-sonnet-4.6",
+  outputSchema: Category,
+});
+```
+
+Other options: `system`, `thinkingLevel`, `temperature`, `maxTokens`, `stepId`.
+
+## Sub-workflows as steps
+
+Reuse a whole workflow by importing it and awaiting `.run(input)` — a first-class durable step, same as an action. Keystroke validates the sub-workflow's `input`/`output`, records its output as a checkpoint keyed `step:<sub-slug>#<occurrence>`, and gives it a trace span.
+
+```ts
+import enrichLead from "./enrich-lead";
+
+async run(input) {
+  const enriched = await enrichLead.run({ email: input.email });
+  return { score: enriched.score };
+}
+```
+
+The sub-workflow runs **inline** in the same run: its inner action/agent/`promptLlm` steps and durable waits (`ctx.sleep` / `ctx.hook`) all stay durable, and it does **not** spawn a separate tracked run. Never thread `ctx` — `enrichLead.run(input, ctx)` is not the pattern; the engine supplies the context. Pin an explicit id with `.stepId("x")` when the call's position can shift. For an *independently tracked* run instead, expose the workflow as an agent tool (`defineWorkflowTool`) or call it over HTTP.
+
+## Durability & retries
+
+As each step completes, its result is written to a run event log. If a later step fails and the run is retried, Keystroke replays the log: completed steps return their recorded result instead of running again, and execution resumes at the first unfinished step. Design for this:
+
+- **Put side effects inside steps.** Work in the `run` body that isn't an action / agent / `promptLlm` call (a raw `fetch`, a DB write, `Date.now()`, `Math.random()`) runs again on every replay. Move it into a step so it's recorded once.
+- **Steps should be idempotent.** A step can be retried after a transient failure, so an action should tolerate being called twice with the same input (use idempotency keys for external writes where it matters).
+- **Keep control flow deterministic.** Branch on the run's input and recorded step results — not on wall-clock time or randomness — so replays take the same path. Each step is recorded under `step:<slug>#<occurrence>`; pin `.stepId("x")` when an action's order can shift so replays still line up. Ids must be unique within a run.
+
+You don't manage retries yourself. The runtime records `step_completed`, `step_retrying`, and `step_failed` events and surfaces them in `keystroke workflow runs get <slug> <run-id> --include steps,trace`.
+
+## Parallel steps
+
+Independent steps run concurrently with `Promise.all` — each `.run()` / `.prompt()` / `promptLlm` inside it is still its own durable step, recorded and replayed individually:
+
+```ts
+const [enriched, scored] = await Promise.all([
+  enrichLead.run({ leadId }),
+  scoreLead.run({ leadId }),
+]);
+```
+
+Correlation ids are assigned per slug in array order (`step:enrich-lead#0`, `step:score-lead#0`). If the branches can change order between attempts (conditionally included, dynamic arrays), pin a stable `.stepId()` on each so replays line up:
+
+```ts
+const results = await Promise.all(
+  leads.map((lead) => enrichLead.run({ leadId: lead.id }).stepId(`enrich:${lead.id}`)),
+);
+```
+
+There's no built-in concurrency limit or fan-out helper — `Promise.all` runs everything at once. For bounded concurrency, batch the array yourself (e.g. chunk and `await` each chunk).
+
+## Handling failures
+
+Retries are **queue-level**: a failed run is re-enqueued (default 3 attempts, exponential backoff) and replays from the event log, so completed steps don't re-run. Each failed attempt emits `step_retrying`; the final failure emits `step_failed`. You don't write retry loops — make steps idempotent so a retried step is safe.
+
+There's no built-in saga, compensation engine, or dead-letter queue. When a later step fails and you need to undo earlier work, orchestrate it yourself with `try/catch` in `run` — catching the error lets the run complete normally (so attach a `compensated` flag to the output rather than rethrowing if you've handled it):
+
+```ts
+async run(input) {
+  await reserveBooking.run({ id: input.bookingId });
+  try {
+    await chargeCustomer.run({ id: input.bookingId });
+    return { ok: true };
+  } catch (error) {
+    await releaseBooking.run({ id: input.bookingId }); // best-effort cleanup
+    return { ok: false, compensated: true };
+  }
+}
+```
+
+If you let the error propagate instead, the run fails and the queue retries it — fine for transient failures, but it replays from the log, so any cleanup must itself be a recorded, idempotent step.
+
+## Durable run context (`ctx`)
+
+`run(input, ctx)` receives a second argument exposing `runId`, `trigger` (`api` | `cron` | `webhook` | `poll` | `retry`), and the durable wait primitives `ctx.sleep(...)` and `ctx.hook(...)`. Both **suspend** the run (the replay engine resumes it later) so long waits and external callbacks don't hold a process open.
+
+```ts
+// Durable delay: number (ms), duration string, or a Date
+await ctx.sleep("1h");
+
+// Durable hook: suspend until an external system POSTs to the resume URL
+async run(input, ctx) {
+  const approval = ctx.hook<{ approved: boolean }>();
+  await slackSendMessage.run({
+    channel: "#approvals",
+    markdown_text: `Approve deploy? ${approval.resumeUrl}`,
+  });
+  const { approved } = await approval; // suspends here until resumed
+  return { approved };
+}
+```
+
+`ctx.hook(options?)` takes an optional `token` (reuse a stable resume token) and `schema` (Zod validation of the resume payload). The returned handle exposes `token` and `resumeUrl` before you await it — surface that URL so the approver/callback can resume the run.
+
+## Agents inside actions
+
+When an action must call an agent (e.g. the action is reused as an agent tool), call `.prompt()` inside the action's `run`. That prompt is not a separate workflow step — the action is.
+
+## Connecting apps
+
+Sync the app into `src/apps/`, author with `app.action()`, then `keystroke connect <slug>` before testing. Catalog integration actions from npm packages work once the app is connected.
+
+## Slugs
+
+Slugs are scoped per primitive kind: a `slug` must be unique among workflows, among agents, and among triggers, but the same `slug` may be reused across kinds (a `pricing` agent and a `pricing` workflow can coexist). The workflow's `slug` is also its HTTP route segment (`POST /workflows/{slug}`).
+
+## Subscription mode
+
+`defineWorkflow` accepts an optional `subscription: { mode: "system" | "subscribable" }` to control how the workflow can be subscribed to. Omit it for the default behavior.

package/dist/skills-bundle/skills/keystroke-workflows/references/testing.md

@@ -0,0 +1,138 @@
+# Testing & debugging workflows
+
+## Unit tests (in-process, no server)
+
+Test through `executeWorkflow` from `@keystrokehq/keystroke/workflow` — it parses input/output and wires up the action/sub-workflow runners. **Never call `workflow.run(...)` directly at the top level of a test**: outside a run it has no durable context (`workflow.run(input)` returns an unresolvable step; `workflow.run(input, ctx)` skips the checkpoint boundary). Inside another workflow body, `await otherWorkflow.run(input)` *is* the correct first-class sub-workflow step.
+
+`executeWorkflow` runs the workflow via the durable replay engine and resolves to a `ReplayResult`: `{ status: "completed", output }`, `{ status: "failed", error }`, `{ status: "suspended", items }` (when the body hits `ctx.sleep`/`ctx.hook`), or `{ status: "canceled" }`. Assert on `status` and read `output`.
+
+`keystroke init` scaffolds Vitest and a starter test (e.g. `src/workflows/greeting.test.ts`):
+
+```ts
+import { describe, expect, it } from "vitest";
+import { executeWorkflow } from "@keystrokehq/keystroke/workflow";
+import greeting from "./greeting";
+
+describe("greeting workflow", () => {
+  it("returns a greeting for a name", async () => {
+    const result = await executeWorkflow(greeting, { name: "Ada" });
+    expect(result).toEqual({ status: "completed", output: { greeting: "Hello, Ada!" } });
+  });
+});
+```
+
+Use `pnpm test:unit` for `src/**/*.test.ts`. Integration tests (`*.int.test.ts`) load `.env` and skip when required keys are unset (`pnpm test:int`).
+
+For multi-step workflows:
+
+```ts
+import { describe, expect, it } from "vitest";
+import { executeWorkflow } from "@keystrokehq/keystroke/workflow";
+import workflow from "../signup-pipeline";
+
+it("runs the pipeline", async () => {
+  const result = await executeWorkflow(workflow, {
+    name: "Ada",
+    email: "ada@acme.com",
+    company: "Acme",
+  });
+
+  expect(result.status).toBe("completed");
+  if (result.status === "completed") {
+    expect(result.output).toMatchObject({ channel: "#pipeline" });
+  }
+});
+```
+
+Deterministic actions (pure logic, no network/LLM) need no mocks — run the workflow and assert.
+
+## Stub expensive actions by seeding the event log
+
+Steps are checkpointed in the durable event log as `step_completed` events keyed by a stable **correlation id**. Before running a step the action runner checks the log for that correlation id; pre-seed a `step_completed` event to skip real work (LLM/agent/HTTP calls) and feed a fixture:
+
+```ts
+import { executeWorkflow, MemoryEventLog } from "@keystrokehq/keystroke/workflow";
+import workflow from "../signup-pipeline";
+
+it("drafts without calling the agent", async () => {
+  const eventLog = new MemoryEventLog();
+  const runId = "test-run";
+
+  // correlation id = `step:<actionKey>#<occurrence>` (occurrence starts at 0),
+  // or `step:<stepId>` if the step used `.stepId("...")`.
+  await eventLog.append({
+    runId,
+    type: "step_completed",
+    correlationId: "step:research-signup#0",
+    data: { brief: "stubbed brief" }, // the action output goes in `data` directly
+  });
+
+  const result = await executeWorkflow(
+    workflow,
+    { name: "Ada", email: "ada@acme.com", company: "Acme" },
+    { runId, eventLog },
+  );
+
+  expect(result.status).toBe("completed");
+  if (result.status === "completed") {
+    expect(result.output).toMatchObject({ brief: "stubbed brief" });
+  }
+});
+```
+
+Rules:
+
+- Pass a fixed `runId` and the same `MemoryEventLog` to `executeWorkflow`.
+- The correlation id is `step:<slug>#<occurrence>` — `#0` for the first call to that action/agent, `#1` for the second, and so on — unless an explicit step id was set (`action.stepId("x")` or `agent.prompt(input, { stepId: "x" })`), in which case it is `step:x`.
+- The action **output** is stored as the event `data` directly (no wrapper). It is re-validated against the action's output schema, so it must be schema-valid.
+
+This is the preferred mock: schema-checked, no module-mock hoisting, and it still exercises the real `run` orchestration (branching, loops, output shape) — only the action bodies are stubbed.
+
+## Mock the integration instead (alternative)
+
+When you'd rather stub the underlying dependency (e.g. the agent inside an action) or assert how it was called, use `vi.mock`:
+
+`agent.prompt()` resolves to a `PromptResponse` — `{ sessionId, messages, error, canceled?, output? }` (`output` is the parsed result when the prompt was called with an `outputSchema`), **not** a bare messages array. Mock that shape:
+
+```ts
+import { vi } from "vitest";
+
+vi.mock("../agents/support", () => ({
+  default: {
+    prompt: vi.fn().mockResolvedValue({
+      sessionId: "test-session",
+      messages: [{ role: "assistant", content: "mocked" }],
+      error: null,
+    }),
+  },
+}));
+```
+
+## Assert the input/output contract
+
+Validation happens at the `executeWorkflow` boundary, so contract tests are free:
+
+```ts
+await expect(executeWorkflow(workflow, { email: "x" } as never)).rejects.toThrow();
+```
+
+## Debug runs from the CLI
+
+```bash
+keystroke workflow run signup-pipeline --input '{"name":"Ada","email":"ada@acme.com","company":"Acme"}'
+keystroke workflow runs list signup-pipeline
+keystroke workflow runs get signup-pipeline <run-id> --include steps,trace
+```
+
+`steps` shows which actions ran and failed. `trace` links nested agent calls.
+
+### Trigger-fired runs
+
+When a cron/webhook/poll fired the workflow:
+
+```bash
+keystroke trigger runs list signup:signup-pipeline
+keystroke trigger runs get signup:signup-pipeline <run-id> --include workflows,trace
+```
+
+While developing triggers, prefer `keystroke workflow run` until the workflow logic is solid.

package/dist/templates/hello-world/.env.example

@@ -0,0 +1,4 @@
+ANTHROPIC_API_KEY=
+BETTER_AUTH_SECRET=dev-better-auth-secret-min-32-chars!!
+PUBLIC_WEB_URL=http://localhost:3000
+PUBLIC_PLATFORM_URL=http://localhost:3002

package/dist/templates/hello-world/README.md

@@ -9,8 +9,7 @@ Keystroke is deploy-first: build in `src/`, deploy to your platform project, the
 ```bash
 pnpm install                          # @keystrokehq/* from GitHub Packages (see .npmrc)
 keystroke auth login                  # once
-keystroke project link --project <slug>  # link this directory (see: keystroke project list)
-keystroke deploy                         # build + ship src/
+keystroke deploy --project <id>       # build + ship src/ (see: keystroke project list)
 ```
 
 <!-- example:start -->
@@ -26,7 +25,7 @@ Use `--filter agents/hello` (or `workflows/greeting`) to redeploy a single modul
 
 ## Run locally (optional)
 
-To iterate offline without deploying, run a local server. Create a `.env` with `ANTHROPIC_API_KEY` and any integration keys, then:
+To iterate offline without deploying, run a local server. Set `ANTHROPIC_API_KEY` and any integration keys in `.env` (created from `.env.example` on init), then:
 
 ```bash
 keystroke dev   # watch src/, rebuild, restart the API (API :3002, dashboard :3000)
@@ -63,5 +62,5 @@ src/
   skills/      # agent skills (SKILL.md)
   triggers/    # cron, webhook, poll attachments
   workflows/   # defineWorkflow
-keystroke.config.ts  # optional server config + platform project/org slugs
+keystroke.config.ts  # optional server + custom integration config
 ```

package/dist/templates/hello-world/package.json

@@ -18,7 +18,6 @@
   },
   "devDependencies": {
     "@keystrokehq/cli": "{{version}}",
-    "@types/node": "{{catalog:@types/node}}",
     "oxlint": "{{catalog:oxlint}}",
     "typescript": "{{catalog:typescript}}",
     "vitest": "{{catalog:vitest}}"

package/dist/templates/hello-world/src/actions/greet.ts

@@ -10,7 +10,6 @@ export const GreetOutput = z.object({
 });
 
 export const greet = defineAction({
-  description: "Greet description.",
   slug: "greet",
   name: "Greet",
   input: GreetInput,

package/dist/templates/hello-world/src/agents/hello.ts

@@ -1,8 +1,6 @@
 import { defineAgent } from "@keystrokehq/keystroke/agent";
 
 export default defineAgent({
-  name: "Hello",
-  description: "Hello description.",
   slug: "hello",
   systemPrompt: "You are a friendly hello-world agent. Keep replies short.",
   model: "anthropic/claude-sonnet-4.6",

package/dist/templates/hello-world/src/workflows/greeting.ts

@@ -4,7 +4,6 @@ import { greet } from "../actions/greet";
 
 export default defineWorkflow({
   slug: "greeting",
-  name: "Greeting",
   description: "Return a friendly greeting for a name.",
   input: z.object({ name: z.string() }),
   output: z.object({ greeting: z.string() }),

package/dist/{version-CiFlKPyE.mjs → version-DcR3O1UD.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { dt as LOCAL_PLATFORM_ORIGIN, er as originFromPublicUrl } from "./dist-DkLbeW8l.mjs";
+import { Kn as originFromPublicUrl, ut as LOCAL_PLATFORM_ORIGIN } from "./dist-BOhrc_Nv.mjs";
 import Conf from "conf";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
@@ -58,6 +58,7 @@ function createCliConfig(cwd = getCliConfigDir()) {
 				default: DEFAULT_PLATFORM_URL
 			},
 			activeOrganizationId: { type: "string" },
+			activeProjectId: { type: "string" },
 			apiTarget: {
 				type: "string",
 				enum: ["local", "platform"]
@@ -165,4 +166,4 @@ function readCliVersion() {
 //#endregion
 export { installPlaygroundDependencies as a, createCliConfig as c, getEffectiveApiTarget as d, getPlatformUrl as f, resolvePlatformUrlForWebUrl as g, DEFAULT_WEB_URL as h, installDependencies as i, getCliConfigDir as l, DEFAULT_PLATFORM_URL as m, buildPlaygroundWorkspace as n, resolvePackageManager as o, getWebUrl as p, detectPackageManager as r, resolveCliRoot as s, readCliVersion as t, getConfigDir as u };
 
-//# sourceMappingURL=version-CiFlKPyE.mjs.map
+//# sourceMappingURL=version-DcR3O1UD.mjs.map

package/dist/version-DcR3O1UD.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"version-DcR3O1UD.mjs","names":[],"sources":["../src/resolve-platform-url.ts","../src/config.ts","../src/project/resolve-cli-root.ts","../src/init/package-manager.ts","../src/version.ts"],"sourcesContent":["import { LOCAL_PLATFORM_ORIGIN, originFromPublicUrl } from \"@keystrokehq/shared\";\n\nexport const DEFAULT_WEB_URL = \"https://keystroke.ai\";\nexport const DEFAULT_PLATFORM_URL = \"https://api.keystroke.ai\";\nexport const LOCAL_WEB_URL = \"http://localhost:3000\";\n\nexport type ResolvePlatformUrlOptions = {\n  platformUrl?: string;\n  /** Used when webUrl does not match a known deployment. */\n  fallback?: string;\n};\n\nfunction webOriginFromUrl(webUrl: string): string {\n  return originFromPublicUrl(webUrl, webUrl.replace(/\\/+$/, \"\"));\n}\n\n/** Known web origins with a fixed platform API — undefined for custom/staging URLs. */\nexport function knownPlatformUrlForWebUrl(webUrl: string): string | undefined {\n  const webOrigin = webOriginFromUrl(webUrl);\n\n  if (webOrigin === LOCAL_WEB_URL || webOrigin === \"http://127.0.0.1:3000\") {\n    return LOCAL_PLATFORM_ORIGIN;\n  }\n\n  if (webOrigin === DEFAULT_WEB_URL) {\n    return DEFAULT_PLATFORM_URL;\n  }\n\n  return undefined;\n}\n\nexport function resolvePlatformUrlForWebUrl(\n  webUrl: string,\n  options: ResolvePlatformUrlOptions = {},\n): string {\n  const explicit = options.platformUrl?.trim();\n  if (explicit) {\n    return explicit.replace(/\\/+$/, \"\");\n  }\n\n  const known = knownPlatformUrlForWebUrl(webUrl);\n  if (known) {\n    return known;\n  }\n\n  const fallback = options.fallback?.trim() || DEFAULT_PLATFORM_URL;\n  return fallback.replace(/\\/+$/, \"\");\n}\n","import Conf from \"conf\";\nimport { homedir } from \"node:os\";\nimport { dirname, join } from \"node:path\";\n\nimport {\n  DEFAULT_PLATFORM_URL,\n  DEFAULT_WEB_URL,\n  knownPlatformUrlForWebUrl,\n  resolvePlatformUrlForWebUrl,\n} from \"./resolve-platform-url\";\n\nexport type ApiTargetMode = \"local\" | \"platform\";\n\nexport type CliConfig = {\n  webUrl: string;\n  platformUrl: string;\n  activeOrganizationId?: string;\n  activeProjectId?: string;\n  apiTarget?: ApiTargetMode;\n};\n\nexport function getCliConfigDir(cwd = join(homedir(), \".keystroke\")): string {\n  return cwd;\n}\n\nexport function getConfigDir(config: Conf<CliConfig>): string {\n  return dirname(config.path);\n}\n\nexport function getEffectiveApiTarget(config: Conf<CliConfig>): ApiTargetMode {\n  const explicit = config.get(\"apiTarget\");\n  if (explicit === \"local\" || explicit === \"platform\") {\n    return explicit;\n  }\n\n  if (process.env.KEYSTROKE_API_KEY?.trim()) {\n    return \"platform\";\n  }\n\n  return \"local\";\n}\n\nfunction syncPlatformUrlWithWebUrl(config: Conf<CliConfig>): void {\n  const webUrl = config.get(\"webUrl\");\n  const known = knownPlatformUrlForWebUrl(webUrl);\n  if (!known) {\n    return;\n  }\n\n  const stored = config.get(\"platformUrl\");\n  if (stored !== known) {\n    config.set(\"platformUrl\", known);\n  }\n}\n\nexport function createCliConfig(cwd = getCliConfigDir()): Conf<CliConfig> {\n  const config = new Conf<CliConfig>({\n    projectName: \"keystroke\",\n    cwd,\n    schema: {\n      webUrl: {\n        type: \"string\",\n        default: DEFAULT_WEB_URL,\n      },\n      platformUrl: {\n        type: \"string\",\n        default: DEFAULT_PLATFORM_URL,\n      },\n      activeOrganizationId: {\n        type: \"string\",\n      },\n      activeProjectId: {\n        type: \"string\",\n      },\n      apiTarget: {\n        type: \"string\",\n        enum: [\"local\", \"platform\"],\n      },\n    },\n  });\n\n  syncPlatformUrlWithWebUrl(config);\n  return config;\n}\n\nexport function getWebUrl(config: Conf<CliConfig>): string {\n  return config.get(\"webUrl\");\n}\n\nexport function getPlatformUrl(config: Conf<CliConfig>): string {\n  const apiKey = process.env.KEYSTROKE_API_KEY?.trim();\n  const fromEnv = process.env.KEYSTROKE_PLATFORM_URL?.trim();\n  if (apiKey && fromEnv) {\n    return fromEnv.replace(/\\/+$/, \"\");\n  }\n  return resolvePlatformUrlForWebUrl(getWebUrl(config), {\n    fallback: config.get(\"platformUrl\"),\n  });\n}\n","import { existsSync, readFileSync } from \"node:fs\";\nimport { dirname, join } from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\n\nfunction isCliPackage(dir: string): boolean {\n  const packageJsonPath = join(dir, \"package.json\");\n  if (!existsSync(packageJsonPath)) {\n    return false;\n  }\n\n  const pkg = JSON.parse(readFileSync(packageJsonPath, \"utf8\")) as { name?: string };\n  return pkg.name === \"@keystrokehq/cli\";\n}\n\nexport function resolveCliRoot(fromModuleUrl: string): string {\n  let dir = dirname(fileURLToPath(fromModuleUrl));\n\n  while (dir !== dirname(dir)) {\n    if (isCliPackage(dir)) {\n      return dir;\n    }\n\n    dir = dirname(dir);\n  }\n\n  throw new Error(\"Could not resolve keystroke CLI package root\");\n}\n","import { spawnSync } from \"node:child_process\";\n\nexport type PackageManager = \"npm\" | \"pnpm\" | \"yarn\" | \"bun\";\n\nconst MANAGERS: PackageManager[] = [\"pnpm\", \"npm\", \"yarn\", \"bun\"];\n\nexport function detectPackageManager(): PackageManager {\n  const userAgent = process.env.npm_config_user_agent ?? \"\";\n\n  for (const manager of MANAGERS) {\n    if (userAgent.startsWith(manager)) {\n      return manager;\n    }\n  }\n\n  if (process.env.PNPM_HOME) {\n    return \"pnpm\";\n  }\n\n  return \"npm\";\n}\n\nexport function resolvePackageManager(explicit?: string): PackageManager {\n  if (!explicit) {\n    return detectPackageManager();\n  }\n\n  const normalized = explicit.trim().toLowerCase();\n  if (!MANAGERS.includes(normalized as PackageManager)) {\n    throw new Error(`Unsupported package manager \"${explicit}\". Use npm, pnpm, yarn, or bun.`);\n  }\n\n  return normalized as PackageManager;\n}\n\n/** Resolve GitHub Packages auth for @keystrokehq/* when NODE_AUTH_TOKEN is unset. */\nexport function resolveGithubPackagesToken(): string | undefined {\n  if (process.env.NODE_AUTH_TOKEN) {\n    return process.env.NODE_AUTH_TOKEN;\n  }\n\n  for (const key of [\"GITHUB_TOKEN\", \"GH_TOKEN\"] as const) {\n    const value = process.env[key];\n    if (value) {\n      return value;\n    }\n  }\n\n  const gh = spawnSync(\"gh\", [\"auth\", \"token\"], { encoding: \"utf8\" });\n  if (gh.status === 0) {\n    const token = gh.stdout.trim();\n    if (token) {\n      return token;\n    }\n  }\n\n  return undefined;\n}\n\nexport function installDependencies(cwd: string, manager: PackageManager): void {\n  const token = resolveGithubPackagesToken();\n  const env = token ? { ...process.env, NODE_AUTH_TOKEN: token } : process.env;\n\n  const result = spawnSync(manager, [\"install\"], {\n    cwd,\n    stdio: \"inherit\",\n    env,\n  });\n\n  if (result.status !== 0) {\n    throw new Error(`${manager} install failed`);\n  }\n}\n\nexport function installPlaygroundDependencies(cwd: string): void {\n  const result = spawnSync(\"pnpm\", [\"install\", \"--ignore-workspace\"], {\n    cwd,\n    stdio: \"inherit\",\n    env: process.env,\n  });\n\n  if (result.status !== 0) {\n    throw new Error(\"pnpm install failed\");\n  }\n}\n\n/**\n * Build every workspace package so the playground's `link:` deps resolve to\n * compiled `dist/`. Without this, `keystroke dev` fails with\n * `ERR_MODULE_NOT_FOUND` against whichever package was never built. Turbo\n * caches, so this is only slow on the first run.\n */\nexport function buildPlaygroundWorkspace(monorepoRoot: string): void {\n  // Build with a clean Node env: the `keystroke-dev` wrapper sets\n  // NODE_OPTIONS=--conditions=development, which would make tsdown/turbo resolve\n  // their own deps to src/ and fail. Dropping NODE_OPTIONS builds to dist/ normally.\n  const { NODE_OPTIONS: _drop, ...buildEnv } = process.env;\n  const result = spawnSync(\"pnpm\", [\"run\", \"build\"], {\n    cwd: monorepoRoot,\n    stdio: \"inherit\",\n    env: buildEnv,\n  });\n\n  if (result.status !== 0) {\n    throw new Error(\"workspace build failed (pnpm run build)\");\n  }\n}\n","import { readFileSync } from \"node:fs\";\nimport { join } from \"node:path\";\nimport { resolveCliRoot } from \"./project/resolve-cli-root\";\n\nexport function readCliVersion(): string {\n  const packageJsonPath = join(resolveCliRoot(import.meta.url), \"package.json\");\n  const pkg = JSON.parse(readFileSync(packageJsonPath, \"utf8\")) as { version?: string };\n  return pkg.version ?? \"0.0.0\";\n}\n"],"mappings":";;;;;;;;;AAEA,MAAa,kBAAkB;AAC/B,MAAa,uBAAuB;AASpC,SAAS,iBAAiB,QAAwB;CAChD,OAAO,oBAAoB,QAAQ,OAAO,QAAQ,QAAQ,EAAE,CAAC;AAC/D;;AAGA,SAAgB,0BAA0B,QAAoC;CAC5E,MAAM,YAAY,iBAAiB,MAAM;CAEzC,IAAI,cAAA,2BAA+B,cAAc,yBAC/C,OAAO;CAGT,IAAI,cAAA,wBACF,OAAO;AAIX;AAEA,SAAgB,4BACd,QACA,UAAqC,CAAC,GAC9B;CACR,MAAM,WAAW,QAAQ,aAAa,KAAK;CAC3C,IAAI,UACF,OAAO,SAAS,QAAQ,QAAQ,EAAE;CAGpC,MAAM,QAAQ,0BAA0B,MAAM;CAC9C,IAAI,OACF,OAAO;CAIT,QADiB,QAAQ,UAAU,KAAK,KAAA,4BACxB,QAAQ,QAAQ,EAAE;AACpC;;;AC1BA,SAAgB,gBAAgB,MAAM,KAAK,QAAQ,GAAG,YAAY,GAAW;CAC3E,OAAO;AACT;AAEA,SAAgB,aAAa,QAAiC;CAC5D,OAAO,QAAQ,OAAO,IAAI;AAC5B;AAEA,SAAgB,sBAAsB,QAAwC;CAC5E,MAAM,WAAW,OAAO,IAAI,WAAW;CACvC,IAAI,aAAa,WAAW,aAAa,YACvC,OAAO;CAGT,IAAI,QAAQ,IAAI,mBAAmB,KAAK,GACtC,OAAO;CAGT,OAAO;AACT;AAEA,SAAS,0BAA0B,QAA+B;CAEhE,MAAM,QAAQ,0BADC,OAAO,IAAI,QACmB,CAAC;CAC9C,IAAI,CAAC,OACH;CAIF,IADe,OAAO,IAAI,aACjB,MAAM,OACb,OAAO,IAAI,eAAe,KAAK;AAEnC;AAEA,SAAgB,gBAAgB,MAAM,gBAAgB,GAAoB;CACxE,MAAM,SAAS,IAAI,KAAgB;EACjC,aAAa;EACb;EACA,QAAQ;GACN,QAAQ;IACN,MAAM;IACN,SAAS;GACX;GACA,aAAa;IACX,MAAM;IACN,SAAS;GACX;GACA,sBAAsB,EACpB,MAAM,SACR;GACA,iBAAiB,EACf,MAAM,SACR;GACA,WAAW;IACT,MAAM;IACN,MAAM,CAAC,SAAS,UAAU;GAC5B;EACF;CACF,CAAC;CAED,0BAA0B,MAAM;CAChC,OAAO;AACT;AAEA,SAAgB,UAAU,QAAiC;CACzD,OAAO,OAAO,IAAI,QAAQ;AAC5B;AAEA,SAAgB,eAAe,QAAiC;CAC9D,MAAM,SAAS,QAAQ,IAAI,mBAAmB,KAAK;CACnD,MAAM,UAAU,QAAQ,IAAI,wBAAwB,KAAK;CACzD,IAAI,UAAU,SACZ,OAAO,QAAQ,QAAQ,QAAQ,EAAE;CAEnC,OAAO,4BAA4B,UAAU,MAAM,GAAG,EACpD,UAAU,OAAO,IAAI,aAAa,EACpC,CAAC;AACH;;;AC9FA,SAAS,aAAa,KAAsB;CAC1C,MAAM,kBAAkB,KAAK,KAAK,cAAc;CAChD,IAAI,CAAC,WAAW,eAAe,GAC7B,OAAO;CAIT,OADY,KAAK,MAAM,aAAa,iBAAiB,MAAM,CAClD,EAAE,SAAS;AACtB;AAEA,SAAgB,eAAe,eAA+B;CAC5D,IAAI,MAAM,QAAQ,cAAc,aAAa,CAAC;CAE9C,OAAO,QAAQ,QAAQ,GAAG,GAAG;EAC3B,IAAI,aAAa,GAAG,GAClB,OAAO;EAGT,MAAM,QAAQ,GAAG;CACnB;CAEA,MAAM,IAAI,MAAM,8CAA8C;AAChE;;;ACtBA,MAAM,WAA6B;CAAC;CAAQ;CAAO;CAAQ;AAAK;AAEhE,SAAgB,uBAAuC;CACrD,MAAM,YAAY,QAAQ,IAAI,yBAAyB;CAEvD,KAAK,MAAM,WAAW,UACpB,IAAI,UAAU,WAAW,OAAO,GAC9B,OAAO;CAIX,IAAI,QAAQ,IAAI,WACd,OAAO;CAGT,OAAO;AACT;AAEA,SAAgB,sBAAsB,UAAmC;CACvE,IAAI,CAAC,UACH,OAAO,qBAAqB;CAG9B,MAAM,aAAa,SAAS,KAAK,EAAE,YAAY;CAC/C,IAAI,CAAC,SAAS,SAAS,UAA4B,GACjD,MAAM,IAAI,MAAM,gCAAgC,SAAS,gCAAgC;CAG3F,OAAO;AACT;;AAGA,SAAgB,6BAAiD;CAC/D,IAAI,QAAQ,IAAI,iBACd,OAAO,QAAQ,IAAI;CAGrB,KAAK,MAAM,OAAO,CAAC,gBAAgB,UAAU,GAAY;EACvD,MAAM,QAAQ,QAAQ,IAAI;EAC1B,IAAI,OACF,OAAO;CAEX;CAEA,MAAM,KAAK,UAAU,MAAM,CAAC,QAAQ,OAAO,GAAG,EAAE,UAAU,OAAO,CAAC;CAClE,IAAI,GAAG,WAAW,GAAG;EACnB,MAAM,QAAQ,GAAG,OAAO,KAAK;EAC7B,IAAI,OACF,OAAO;CAEX;AAGF;AAEA,SAAgB,oBAAoB,KAAa,SAA+B;CAC9E,MAAM,QAAQ,2BAA2B;CASzC,IANe,UAAU,SAAS,CAAC,SAAS,GAAG;EAC7C;EACA,OAAO;EACP,KALU,QAAQ;GAAE,GAAG,QAAQ;GAAK,iBAAiB;EAAM,IAAI,QAAQ;CAMzE,CAES,EAAE,WAAW,GACpB,MAAM,IAAI,MAAM,GAAG,QAAQ,gBAAgB;AAE/C;AAEA,SAAgB,8BAA8B,KAAmB;CAO/D,IANe,UAAU,QAAQ,CAAC,WAAW,oBAAoB,GAAG;EAClE;EACA,OAAO;EACP,KAAK,QAAQ;CACf,CAES,EAAE,WAAW,GACpB,MAAM,IAAI,MAAM,qBAAqB;AAEzC;;;;;;;AAQA,SAAgB,yBAAyB,cAA4B;CAInE,MAAM,EAAE,cAAc,OAAO,GAAG,aAAa,QAAQ;CAOrD,IANe,UAAU,QAAQ,CAAC,OAAO,OAAO,GAAG;EACjD,KAAK;EACL,OAAO;EACP,KAAK;CACP,CAES,EAAE,WAAW,GACpB,MAAM,IAAI,MAAM,yCAAyC;AAE7D;;;ACtGA,SAAgB,iBAAyB;CACvC,MAAM,kBAAkB,KAAK,eAAe,OAAO,KAAK,GAAG,GAAG,cAAc;CAE5E,OADY,KAAK,MAAM,aAAa,iBAAiB,MAAM,CAClD,EAAE,WAAW;AACxB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keystrokehq/cli",
-  "version": "0.1.38",
+  "version": "0.2.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/keystrokehq/keystroke.git",
@@ -29,8 +29,7 @@
     "conf": "^15.1.0",
     "drizzle-orm": "^0.45.2",
     "picomatch": "^4.0.4",
-    "tsdown": "^0.22.0",
-    "typescript": "^6.0.3"
+    "tsdown": "^0.22.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",
@@ -39,11 +38,12 @@
     "oxlint": "^1.66.0",
     "tsdown": "^0.22.0",
     "tsx": "^4.22.3",
+    "typescript": "^6.0.3",
     "vitest": "^4.1.7",
     "@keystrokehq/oxlint-config": "0.0.4",
     "@keystrokehq/tsconfig": "0.0.3",
-    "@keystrokehq/tsdown-config": "0.0.5",
-    "@keystrokehq/vitest-config": "0.0.7"
+    "@keystrokehq/tsdown-config": "0.0.3",
+    "@keystrokehq/vitest-config": "0.0.6"
   },
   "scripts": {
     "build": "tsx scripts/generate-catalog-versions.ts && tsdown && node scripts/copy-templates.mjs && node scripts/copy-skills-bundle.mjs",