@kimchi-dev/kimchictl 0.0.8 → 0.0.10

package/src/commands/templates.ts

@@ -0,0 +1,222 @@
+import { formatAge, formatBytes, formatMillicores } from "../api/resources.js"
+import {
+	AmbiguousTemplateError,
+	getWorkspaceTemplate,
+	listWorkspaceTemplates,
+	TemplateNotFoundError,
+	type WorkspaceTemplate,
+} from "../api/templates.js"
+import { requireApiKey } from "../auth/resolve.js"
+import { parseFlags, UsageError } from "./flags.js"
+import { guardCommand } from "./guard.js"
+import { formatTable } from "./table.js"
+
+export interface TemplatesDeps {
+	fetch?: typeof globalThis.fetch
+	env?: NodeJS.ProcessEnv
+	/** Override TTY interactivity detection (tests). */
+	interactive?: boolean
+	/** Clock override for deterministic AGE columns (tests). */
+	now?: () => Date
+	/** ANSI colors on stdout (tests); defaults to stdout being a TTY. */
+	color?: boolean
+}
+
+const TEMPLATES_USAGE = `Usage:
+  kimchictl templates <verb> [options]
+
+Verbs:
+  list   List workspace templates  (alias: ls)
+  get    Show template details
+
+Options:
+  --help   Show this help`
+
+/** `kimchictl templates <verb> …` — read-only browse of workspace templates. */
+export async function runTemplates(args: string[], deps: TemplatesDeps = {}): Promise<number> {
+	const [verb, ...rest] = args
+	switch (verb) {
+		case "list":
+		case "ls":
+			return runTemplatesList(rest, deps)
+		case "get":
+			return runTemplatesGet(rest, deps)
+		case "help":
+		case "--help":
+		case "-h":
+			console.log(TEMPLATES_USAGE)
+			return 0
+		case undefined:
+			console.error(TEMPLATES_USAGE)
+			return 2
+		default:
+			console.error(`kimchictl templates: unknown verb "${verb}"`)
+			console.error(TEMPLATES_USAGE)
+			return 2
+	}
+}
+
+async function runTemplatesList(args: string[], deps: TemplatesDeps): Promise<number> {
+	const { values, positionals } = parseFlags("templates list", args, {
+		output: { type: "string", short: "o", default: "table" },
+	})
+	if (values.help) {
+		console.log(`Usage:
+  kimchictl templates list [options]
+
+Options:
+  --output <format>   Output format: table | json (default: table)
+  --help              Show this help`)
+		return 0
+	}
+	if (positionals.length > 0) {
+		throw new UsageError("kimchictl templates list: unexpected positional argument")
+	}
+	if (values.output !== "json" && values.output !== "table") {
+		throw new UsageError(
+			`kimchictl templates list: unsupported --output "${String(values.output)}" (expected table|json)`,
+		)
+	}
+
+	const { key } = requireApiKey(deps.env)
+	const templates = await listWorkspaceTemplates(key, { fetch: deps.fetch })
+
+	if (values.output === "json") {
+		console.log(JSON.stringify(templates.map(serializeTemplate), null, 2))
+		return 0
+	}
+
+	const now = deps.now?.() ?? new Date()
+	const rows = templates.map((t) => [
+		t.name || t.id.slice(0, 12),
+		t.description.length > 40 ? `${t.description.slice(0, 37)}…` : t.description || "-",
+		formatMillicores(t.spec?.resources?.cpu ? parseQuantity(t.spec.resources.cpu) : undefined),
+		formatBytes(t.spec?.resources?.memory ? parseByteQuantity(t.spec.resources.memory) : undefined),
+		formatBytes(t.spec?.resources?.pvcSize ? parseByteQuantity(t.spec.resources.pvcSize) : undefined),
+		formatAge(t.createTime, now),
+	])
+	console.log(formatTable(["NAME", "DESCRIPTION", "CPU", "MEMORY", "STORAGE", "AGE"], rows))
+	return 0
+}
+
+async function runTemplatesGet(args: string[], deps: TemplatesDeps): Promise<number> {
+	const { values, positionals } = parseFlags("templates get", args, {
+		output: { type: "string", short: "o", default: "text" },
+	})
+	if (values.help) {
+		console.log(`Usage:
+  kimchictl templates get <name-or-id> [options]
+
+Options:
+  --output <format>   Output format: text | json (default: text)
+  --help              Show this help`)
+		return 0
+	}
+	if (positionals.length !== 1) {
+		throw new UsageError("kimchictl templates get: expected exactly one template name or ID")
+	}
+	if (values.output !== "json" && values.output !== "text") {
+		throw new UsageError(
+			`kimchictl templates get: unsupported --output "${String(values.output)}" (expected text|json)`,
+		)
+	}
+
+	const { key } = requireApiKey(deps.env)
+	const ref = positionals[0] ?? ""
+
+	// Templates are addressed by ID in the API; when the ref is a name,
+	// list-and-match (the API has no by-name lookup).
+	let template: WorkspaceTemplate | undefined
+	if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(ref)) {
+		template = await getWorkspaceTemplate(key, ref, { fetch: deps.fetch })
+	} else {
+		const all = await listWorkspaceTemplates(key, { fetch: deps.fetch })
+		const matches = all.filter((t) => t.name === ref || t.name.startsWith(ref))
+		if (matches.length === 0) throw new TemplateNotFoundError(ref)
+		if (matches.length > 1)
+			throw new AmbiguousTemplateError(
+				ref,
+				matches.map((t) => t.name),
+			)
+		template = matches[0]
+	}
+	if (!template) throw new TemplateNotFoundError(ref)
+
+	if (values.output === "json") {
+		console.log(JSON.stringify(serializeTemplate(template), null, 2))
+		return 0
+	}
+
+	for (const line of renderTemplateCard(template, deps.color ?? false, deps.now?.() ?? new Date())) {
+		console.log(line)
+	}
+	return 0
+}
+
+function renderTemplateCard(template: WorkspaceTemplate, color: boolean, now: Date): string[] {
+	const dimText = (text: string) => (color ? `\x1b[2m${text}\x1b[0m` : text)
+	const lines: string[] = [`${template.name || template.id.slice(0, 12)}  ${dimText("template")}`]
+	if (template.description) lines.push(dimText(`  ${template.description}`))
+
+	const parts: string[] = []
+	const res = template.spec?.resources
+	if (res) {
+		if (res.cpu) parts.push(formatMillicores(parseQuantity(res.cpu)))
+		if (res.memory) parts.push(formatBytes(parseByteQuantity(res.memory)))
+	}
+	if (parts.length > 0) {
+		lines.push(dimText(`  ${parts.join(" · ")}`))
+	}
+
+	const dependencies = template.spec?.dependencies
+	if (dependencies && dependencies.length > 0) {
+		lines.push(`  deps  ${dependencies.join(", ")}`)
+	}
+
+	const eg = template.spec?.egressPolicy
+	if (eg) {
+		const egParts: string[] = []
+		if (eg.denyByDefault === false) egParts.push("default-allow")
+		if (eg.allowed && eg.allowed.length > 0) egParts.push(`allow: ${eg.allowed.join(", ")}`)
+		if (eg.denied && eg.denied.length > 0) egParts.push(`deny: ${eg.denied.join(", ")}`)
+		if (egParts.length > 0) lines.push(dimText(`  egress  ${egParts.join(" · ")}`))
+	}
+
+	lines.push(dimText(`  updated ${formatAge(template.updateTime, now)} ago`))
+	return lines
+}
+
+function serializeTemplate(t: WorkspaceTemplate): Record<string, unknown> {
+	return {
+		id: t.id,
+		name: t.name,
+		...(t.description ? { description: t.description } : {}),
+		spec: t.spec,
+		...(t.createdBy ? { createdBy: t.createdBy } : {}),
+		...(t.updateTime.getTime() > 0 ? { updateTime: t.updateTime.toISOString() } : {}),
+	}
+}
+
+/** Parse a k8s CPU quantity string ("500m", "2") to millicores. */
+function parseQuantity(q: string): number | undefined {
+	const value = Number.parseFloat(q.replace(/m$/, ""))
+	if (Number.isNaN(value)) return undefined
+	return q.endsWith("m") ? value : value * 1000
+}
+
+/** Parse a k8s memory/storage quantity string ("1Gi", "512Mi") to bytes. */
+function parseByteQuantity(q: string): number | undefined {
+	const units: Record<string, number> = { Ki: 1024, Mi: 1024 ** 2, Gi: 1024 ** 3, Ti: 1024 ** 4 }
+	for (const [suffix, mult] of Object.entries(units)) {
+		if (q.endsWith(suffix)) {
+			const value = Number.parseFloat(q.slice(0, -suffix.length))
+			if (!Number.isNaN(value)) return value * mult
+		}
+	}
+	const value = Number.parseFloat(q)
+	if (!Number.isNaN(value)) return value
+	return undefined
+}
+
+/** Canonical harness-package entry: guard exit codes for the kimchi.commands manifest. */
+export const run: (args: string[], deps?: TemplatesDeps) => Promise<number> = guardCommand(runTemplates)

package/src/commands/workspace.test.ts

@@ -323,11 +323,11 @@ describe("kimchictl workspace list", () => {
 		expect(code).toBe(0)
 		// formatTable prints the whole table as one console call.
 		const table = lines[0]?.split("\n") ?? []
-		expect(table[0]).toMatch(/^NAME\s+STATUS\s+CLUSTER\s+AGE\s+CPU\s+RAM\s+PVC\s+URI$/)
+		expect(table[0]).toMatch(/^NAME\s+STATUS\s+CLUSTER\s+TEMPLATE\s+AGE\s+CPU\s+RAM\s+PVC\s+URI$/)
 		expect(table[1]).toMatch(
-			/^bright-oak-otter\s+active\s+krep-us\s+3h\s+2\s+4Gi\s+20Gi\s+bright-oak-otter\.remote\.kimchi\.dev$/,
+			/^bright-oak-otter\s+active\s+krep-us\s+-\s+3h\s+2\s+4Gi\s+20Gi\s+bright-oak-otter\.remote\.kimchi\.dev$/,
 		)
-		expect(table[2]).toMatch(/^demo\s+suspended\s+krep-us\s+2d\s+-\s+-\s+-\s+demo\.remote\.kimchi\.dev$/)
+		expect(table[2]).toMatch(/^demo\s+suspended\s+krep-us\s+-\s+2d\s+-\s+-\s+-\s+demo\.remote\.kimchi\.dev$/)
 		expect(table).toHaveLength(3)
 	})
 
@@ -338,7 +338,7 @@ describe("kimchictl workspace list", () => {
 		expect(JSON.parse(jsonRun.lines.join(""))).toEqual([])
 
 		const tableRun = await run(["list"], fetch)
-		expect(tableRun.lines).toEqual(["NAME  STATUS  CLUSTER  AGE  CPU  RAM  PVC  URI"])
+		expect(tableRun.lines).toEqual(["NAME  STATUS  CLUSTER  TEMPLATE  AGE  CPU  RAM  PVC  URI"])
 	})
 
 	it("rejects an unsupported output flavor", async () => {
@@ -429,99 +429,6 @@ describe("kimchictl workspace get", () => {
 
 // ---------------------------------------------------------------- delete
 
-describe("kimchictl workspace templates", () => {
-	const TEMPLATE_JSON = {
-		id: "aaaa1111-2222-3333-4444-555555555555",
-		organizationId: "org-1",
-		name: "rust",
-		description: "Rust workspace",
-		spec: {
-			resources: { cpu: "2", memory: "4Gi", pvcSize: "20Gi" },
-			dependencies: ["jq", "node@22"],
-			egressPolicy: { denyByDefault: true, allowed: ["*.github.com"] },
-			initScript: "echo hi",
-		},
-		createdBy: "user-1",
-		updatedBy: "user-1",
-		createTime: "2026-01-01T00:00:00Z",
-		updateTime: "2026-01-01T00:00:00Z",
-	}
-
-	function templateFetch(items: unknown[]): typeof globalThis.fetch {
-		return stubFetch(async (url, init) => {
-			if (init?.method === "POST" || (init?.method ?? "GET") === "POST") {
-				if (url.endsWith("workspace-tokens:verifyKey")) return jsonResponse({ organizationId: "org-1" })
-			}
-			if (url.endsWith("workspace-tokens:verifyKey")) return jsonResponse({ organizationId: "org-1" })
-			if (url.includes("workspace-templates?")) return jsonResponse({ items })
-			if (url.endsWith("/workspace-templates/aaaa1111-2222-3333-4444-555555555555")) {
-				return jsonResponse(items[0])
-			}
-			throw new Error(`unexpected: ${init?.method ?? "GET"} ${url}`)
-		}) as typeof globalThis.fetch
-	}
-
-	it("prints group usage on help / missing verb", async () => {
-		const { code, lines } = await run(["templates", "help"], templateFetch([]))
-		expect(code).toBe(0)
-		expect(lines[0]).toContain("kimchictl workspace templates <verb>")
-	})
-
-	it("renders the template table", async () => {
-		const { code, lines } = await run(["templates", "list"], templateFetch([TEMPLATE_JSON]), {
-			now: () => new Date("2026-01-01T03:00:00Z"),
-		})
-		expect(code).toBe(0)
-		const table = lines[0]?.split("\n") ?? []
-		expect(table[0]).toMatch(/^NAME\s+DESCRIPTION\s+CPU\s+MEMORY\s+STORAGE\s+AGE$/)
-		expect(table[1]).toMatch(/^rust\s+Rust workspace\s+2\s+4Gi\s+20Gi\s+3h$/)
-	})
-
-	it("renders json output", async () => {
-		const { code, lines } = await run(["templates", "list", "--output", "json"], templateFetch([TEMPLATE_JSON]))
-		expect(code).toBe(0)
-		const parsed = JSON.parse(lines.join(""))
-		expect(parsed[0]).toMatchObject({ name: "rust", description: "Rust workspace" })
-	})
-
-	it("renders the template detail card by name", async () => {
-		const { code, lines } = await run(["templates", "get", "rust"], templateFetch([TEMPLATE_JSON]), {
-			now: () => new Date("2026-01-01T03:00:00Z"),
-		})
-		expect(code).toBe(0)
-		const text = lines.join("\n")
-		expect(text).toContain("rust  template")
-		expect(text).toContain("Rust workspace")
-		expect(text).toContain("deps  jq, node@22")
-		expect(text).toContain("egress  allow: *.github.com")
-	})
-
-	it("resolves by UUID without listing", async () => {
-		const fetch = templateFetch([TEMPLATE_JSON])
-		const calls: string[] = []
-		const trackedFetch = stubFetch(async (url, init) => {
-			calls.push(url)
-			return fetch(url, init)
-		}) as typeof globalThis.fetch
-
-		const { code } = await run(["templates", "get", "aaaa1111-2222-3333-4444-555555555555"], trackedFetch)
-		expect(code).toBe(0)
-		// No list call — the UUID went straight to GET
-		expect(calls.some((u) => u.includes("workspace-templates?"))).toBe(false)
-	})
-
-	it("errors on unknown template", async () => {
-		const { code, errors } = await run(["templates", "get", "nope"], templateFetch([]))
-		expect(code).toBe(1)
-		expect(errors[0]).toContain('No workspace template matches "nope"')
-	})
-
-	it("rejects unknown verbs and bad output", async () => {
-		expect((await run(["templates", "frobnicate"], templateFetch([]))).code).toBe(2)
-		expect((await run(["templates", "list", "--output", "yaml"], templateFetch([]))).code).toBe(2)
-	})
-})
-
 describe("kimchictl workspace delete", () => {
 	it("deletes after an affirmative confirmation", async () => {
 		const fetch = apiFetch([

package/src/commands/workspace.ts

@@ -2,13 +2,6 @@ import { readFileSync } from "node:fs"
 import { resolve } from "node:path"
 import { resolveWorkspace } from "../api/resolver.js"
 import { formatAge, formatBytes, formatMillicores } from "../api/resources.js"
-import {
-	AmbiguousTemplateError,
-	getWorkspaceTemplate,
-	listWorkspaceTemplates,
-	TemplateNotFoundError,
-	type WorkspaceTemplate,
-} from "../api/templates.js"
 import { waitForWorkspaceActive } from "../api/wait.js"
 import {
 	type CreateWorkspaceSpec,
@@ -43,11 +36,10 @@ const GROUP_USAGE = `Usage:
   kimchictl workspace <verb> [options]
 
 Verbs:
-  create     Create a workspace (server generates the alias)
-  list       List workspaces  (alias: ls)
-  get        Show workspace details
-  delete     Delete a workspace  (alias: rm)
-  templates  Browse workspace templates (list | get)
+  create   Create a workspace (server generates the alias)
+  list     List workspaces  (alias: ls)
+  get      Show workspace details
+  delete   Delete a workspace  (alias: rm)
 
 Create options:
   --desc <text>              Description
@@ -81,9 +73,6 @@ export async function runWorkspace(args: string[], deps: WorkspaceDeps = {}): Pr
 		case "delete":
 		case "rm":
 			return runDelete(rest, deps)
-		case "templates":
-		case "template":
-			return runTemplates(rest, deps)
 		case "help":
 		case "--help":
 		case "-h":
@@ -99,6 +88,25 @@ export async function runWorkspace(args: string[], deps: WorkspaceDeps = {}): Pr
 
 // ---------------------------------------------------------------- create
 
+const CREATE_USAGE = `Usage:
+  kimchictl workspace create [options]
+
+Options:
+  --desc <text>              Description
+  --template <name>          Workspace template (conflicts with spec flags)
+  --template-id <uuid>       Template ID (alternative to --template)
+  --cpu <qty>               CPU request (e.g. "500m", "2")
+  --memory <qty>             Memory request (e.g. "1Gi", "512Mi")
+  --storage <qty>            PVC size (e.g. "20Gi")
+  --dep <tool>               CLI tool to install (repeatable, e.g. --dep jq --dep node@22)
+  --egress-allow <dest>      Allow egress destination (repeatable)
+  --egress-deny <dest>       Deny egress destination (repeatable)
+  --egress-default-allow     Default-allow egress (instead of deny-by-default)
+  --init-script <script>     Boot script (or @file to read from file)
+  --no-wait                  Skip waiting for ACTIVE
+  --timeout <seconds>        Wait timeout (default 60)
+  --help                     Show this help`
+
 async function runCreate(args: string[], deps: WorkspaceDeps): Promise<number> {
 	const { values, positionals } = parseFlags("workspace create", args, {
 		desc: { type: "string" },
@@ -115,6 +123,10 @@ async function runCreate(args: string[], deps: WorkspaceDeps): Promise<number> {
 		"no-wait": { type: "boolean" },
 		timeout: { type: "string", default: "60" },
 	})
+	if (values.help) {
+		console.log(CREATE_USAGE)
+		return 0
+	}
 	if (positionals.length > 0) {
 		throw new UsageError(
 			"kimchictl workspace create: unexpected positional argument (workspaces are named by the server)",
@@ -251,6 +263,15 @@ async function runList(args: string[], deps: WorkspaceDeps): Promise<number> {
 	const { values, positionals } = parseFlags("workspace list", args, {
 		output: { type: "string", short: "o", default: "table" },
 	})
+	if (values.help) {
+		console.log(`Usage:
+  kimchictl workspace list [options]
+
+Options:
+  --output <format>   Output format: table | json (default: table)
+  --help              Show this help`)
+		return 0
+	}
 	if (positionals.length > 0) {
 		throw new UsageError("kimchictl workspace list: unexpected positional argument")
 	}
@@ -274,13 +295,14 @@ async function runList(args: string[], deps: WorkspaceDeps): Promise<number> {
 		w.alias,
 		w.status,
 		w.cluster,
+		w.templateName || "-",
 		formatAge(w.createdAt, now),
 		formatMillicores(w.cpuMillicores),
 		formatBytes(w.ramBytes),
 		formatBytes(w.pvcSizeBytes),
 		w.uri ?? "",
 	])
-	console.log(formatTable(["NAME", "STATUS", "CLUSTER", "AGE", "CPU", "RAM", "PVC", "URI"], rows))
+	console.log(formatTable(["NAME", "STATUS", "CLUSTER", "TEMPLATE", "AGE", "CPU", "RAM", "PVC", "URI"], rows))
 	return 0
 }
 
@@ -290,6 +312,15 @@ async function runGet(args: string[], deps: WorkspaceDeps): Promise<number> {
 	const { values, positionals } = parseFlags("workspace get", args, {
 		output: { type: "string", short: "o", default: "text" },
 	})
+	if (values.help) {
+		console.log(`Usage:
+  kimchictl workspace get <name> [options]
+
+Options:
+  --output <format>   Output format: text | json (default: text)
+  --help              Show this help`)
+		return 0
+	}
 	if (positionals.length !== 1) {
 		throw new UsageError("kimchictl workspace get: expected exactly one workspace name")
 	}
@@ -320,6 +351,15 @@ async function runDelete(args: string[], deps: WorkspaceDeps): Promise<number> {
 	const { values, positionals } = parseFlags("workspace delete", args, {
 		force: { type: "boolean", short: "f" },
 	})
+	if (values.help) {
+		console.log(`Usage:
+  kimchictl workspace delete <name> [options]
+
+Options:
+  --force, -f    Skip the confirmation prompt
+  --help          Show this help`)
+		return 0
+	}
 	if (positionals.length !== 1) {
 		throw new UsageError("kimchictl workspace delete: expected exactly one workspace name")
 	}
@@ -349,184 +389,6 @@ async function runDelete(args: string[], deps: WorkspaceDeps): Promise<number> {
 	return 0
 }
 
-// ---------------------------------------------------------------- templates
-
-async function runTemplates(args: string[], deps: WorkspaceDeps): Promise<number> {
-	const [verb, ...rest] = args
-	switch (verb) {
-		case "list":
-		case "ls":
-			return runTemplatesList(rest, deps)
-		case "get":
-			return runTemplatesGet(rest, deps)
-		case "help":
-		case "--help":
-		case "-h":
-			console.log(TEMPLATES_USAGE)
-			return 0
-		case undefined:
-			console.error(TEMPLATES_USAGE)
-			return 2
-		default:
-			console.error(`kimchictl workspace templates: unknown verb "${verb}"`)
-			console.error(TEMPLATES_USAGE)
-			return 2
-	}
-}
-
-const TEMPLATES_USAGE = `Usage:
-  kimchictl workspace templates <verb> [options]
-
-Verbs:
-  list   List workspace templates  (alias: ls)
-  get    Show template details
-
-Options:
-  --help   Show this help`
-
-async function runTemplatesList(args: string[], deps: WorkspaceDeps): Promise<number> {
-	const { values, positionals } = parseFlags("workspace templates list", args, {
-		output: { type: "string", short: "o", default: "table" },
-	})
-	if (positionals.length > 0) {
-		throw new UsageError("kimchictl workspace templates list: unexpected positional argument")
-	}
-	if (values.output !== "json" && values.output !== "table") {
-		throw new UsageError(
-			`kimchictl workspace templates list: unsupported --output "${String(values.output)}" (expected table|json)`,
-		)
-	}
-
-	const { key } = requireApiKey(deps.env)
-	const templates = await listWorkspaceTemplates(key, { fetch: deps.fetch })
-
-	if (values.output === "json") {
-		console.log(JSON.stringify(templates.map(serializeTemplate), null, 2))
-		return 0
-	}
-
-	const now = deps.now?.() ?? new Date()
-	const rows = templates.map((t) => [
-		t.name || t.id.slice(0, 12),
-		t.description.length > 40 ? `${t.description.slice(0, 37)}…` : t.description || "-",
-		formatMillicores(t.spec?.resources?.cpu ? parseQuantity(t.spec.resources.cpu) : undefined),
-		formatBytes(t.spec?.resources?.memory ? parseByteQuantity(t.spec.resources.memory) : undefined),
-		formatBytes(t.spec?.resources?.pvcSize ? parseByteQuantity(t.spec.resources.pvcSize) : undefined),
-		formatAge(t.createTime, now),
-	])
-	console.log(formatTable(["NAME", "DESCRIPTION", "CPU", "MEMORY", "STORAGE", "AGE"], rows))
-	return 0
-}
-
-async function runTemplatesGet(args: string[], deps: WorkspaceDeps): Promise<number> {
-	const { values, positionals } = parseFlags("workspace templates get", args, {
-		output: { type: "string", short: "o", default: "text" },
-	})
-	if (positionals.length !== 1) {
-		throw new UsageError("kimchictl workspace templates get: expected exactly one template name or ID")
-	}
-	if (values.output !== "json" && values.output !== "text") {
-		throw new UsageError(
-			`kimchictl workspace templates get: unsupported --output "${String(values.output)}" (expected text|json)`,
-		)
-	}
-
-	const { key } = requireApiKey(deps.env)
-	const ref = positionals[0] ?? ""
-
-	// Templates are addressed by ID in the API; when the ref is a name,
-	// list-and-match (the API has no by-name lookup).
-	let template: WorkspaceTemplate | undefined
-	if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(ref)) {
-		template = await getWorkspaceTemplate(key, ref, { fetch: deps.fetch })
-	} else {
-		const all = await listWorkspaceTemplates(key, { fetch: deps.fetch })
-		const matches = all.filter((t) => t.name === ref || t.name.startsWith(ref))
-		if (matches.length === 0) throw new TemplateNotFoundError(ref)
-		if (matches.length > 1)
-			throw new AmbiguousTemplateError(
-				ref,
-				matches.map((t) => t.name),
-			)
-		template = matches[0]
-	}
-	if (!template) throw new TemplateNotFoundError(ref)
-
-	if (values.output === "json") {
-		console.log(JSON.stringify(serializeTemplate(template), null, 2))
-		return 0
-	}
-
-	for (const line of renderTemplateCard(template, deps.color ?? false, deps.now?.() ?? new Date())) {
-		console.log(line)
-	}
-	return 0
-}
-
-function renderTemplateCard(template: WorkspaceTemplate, color: boolean, now: Date): string[] {
-	const lines: string[] = [`${template.name || template.id.slice(0, 12)}  ${dim("template", color)}`]
-	if (template.description) lines.push(dim(`  ${template.description}`, color))
-
-	const parts: string[] = []
-	const res = template.spec?.resources
-	if (res) {
-		if (res.cpu) parts.push(formatMillicores(parseQuantity(res.cpu)))
-		if (res.memory) parts.push(formatBytes(parseByteQuantity(res.memory)))
-	}
-	if (parts.length > 0) {
-		lines.push(dim(`  ${parts.join(" · ")}`, color))
-	}
-
-	const deps = template.spec?.dependencies
-	if (deps && deps.length > 0) {
-		lines.push(`  deps  ${deps.join(", ")}`)
-	}
-
-	const eg = template.spec?.egressPolicy
-	if (eg) {
-		const egParts: string[] = []
-		if (eg.denyByDefault === false) egParts.push("default-allow")
-		if (eg.allowed && eg.allowed.length > 0) egParts.push(`allow: ${eg.allowed.join(", ")}`)
-		if (eg.denied && eg.denied.length > 0) egParts.push(`deny: ${eg.denied.join(", ")}`)
-		if (egParts.length > 0) lines.push(dim(`  egress  ${egParts.join(" · ")}`, color))
-	}
-
-	lines.push(dim(`  updated ${formatAge(template.updateTime, now)} ago`, color))
-	return lines
-}
-
-function serializeTemplate(t: WorkspaceTemplate): Record<string, unknown> {
-	return {
-		id: t.id,
-		name: t.name,
-		...(t.description ? { description: t.description } : {}),
-		spec: t.spec,
-		...(t.createdBy ? { createdBy: t.createdBy } : {}),
-		...(t.updateTime.getTime() > 0 ? { updateTime: t.updateTime.toISOString() } : {}),
-	}
-}
-
-/** Parse a k8s CPU quantity string ("500m", "2") to millicores. */
-function parseQuantity(q: string): number | undefined {
-	const value = Number.parseFloat(q.replace(/m$/, ""))
-	if (Number.isNaN(value)) return undefined
-	return q.endsWith("m") ? value : value * 1000
-}
-
-/** Parse a k8s memory/storage quantity string ("1Gi", "512Mi") to bytes. */
-function parseByteQuantity(q: string): number | undefined {
-	const units: Record<string, number> = { Ki: 1024, Mi: 1024 ** 2, Gi: 1024 ** 3, Ti: 1024 ** 4 }
-	for (const [suffix, mult] of Object.entries(units)) {
-		if (q.endsWith(suffix)) {
-			const value = Number.parseFloat(q.slice(0, -suffix.length))
-			if (!Number.isNaN(value)) return value * mult
-		}
-	}
-	const value = Number.parseFloat(q)
-	if (!Number.isNaN(value)) return value
-	return undefined
-}
-
 // ---------------------------------------------------------------- shared
 
 /** Tinted status dot: green=active, yellow=transitional/suspended, dim=terminated. */
@@ -560,6 +422,7 @@ function renderWorkspaceCard(
 	const meta = [
 		workspace.cluster ? `cluster ${workspace.cluster}` : "",
 		workspace.clientType,
+		workspace.templateName ? `from ${workspace.templateName}` : "",
 		`created ${formatAge(workspace.createdAt, now)} ago`,
 	].filter(Boolean)
 	if (meta.length > 0) lines.push(dim(`  ${meta.join(" · ")}`, color))
@@ -593,6 +456,7 @@ function serializeWorkspace(w: Workspace): Record<string, unknown> {
 		status: w.status,
 		...(w.cluster ? { cluster: w.cluster } : {}),
 		...(w.clientType ? { clientType: w.clientType } : {}),
+		...(w.templateName ? { templateName: w.templateName } : {}),
 		...(w.uri ? { uri: w.uri } : {}),
 		createdAt: w.createdAt.getTime() > 0 ? w.createdAt.toISOString() : undefined,
 		resources: {

package/src/version.ts

@@ -3,4 +3,4 @@
  * version over this constant at build time; the committed value stays a
  * sentinel so source checkouts are recognizable.
  */
-export const VERSION = "0.0.8"
+export const VERSION = "0.0.10"