@kici-dev/compiler 0.0.0 → 0.1.2

package/dist/assets/package-BpQF9kR8.json

@@ -0,0 +1,74 @@
+{
+	"name": "winston",
+	"description": "A logger for just about everything.",
+	"version": "3.19.0",
+	"author": "Charlie Robbins <charlie.robbins@gmail.com>",
+	"maintainers": [
+		"David Hyde <dabh@alumni.stanford.edu>"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/winstonjs/winston.git"
+	},
+	"keywords": [
+		"winston",
+		"logger",
+		"logging",
+		"logs",
+		"sysadmin",
+		"bunyan",
+		"pino",
+		"loglevel",
+		"tools",
+		"json",
+		"stream"
+	],
+	"dependencies": {
+		"@dabh/diagnostics": "^2.0.8",
+		"@colors/colors": "^1.6.0",
+		"async": "^3.2.3",
+		"is-stream": "^2.0.0",
+		"logform": "^2.7.0",
+		"one-time": "^1.0.0",
+		"readable-stream": "^3.4.0",
+		"safe-stable-stringify": "^2.3.1",
+		"stack-trace": "0.0.x",
+		"triple-beam": "^1.3.0",
+		"winston-transport": "^4.9.0"
+	},
+	"devDependencies": {
+		"@babel/cli": "^7.23.9",
+		"@babel/core": "^7.24.0",
+		"@babel/preset-env": "^7.24.0",
+		"@dabh/eslint-config-populist": "^4.4.0",
+		"@types/node": "^20.11.24",
+		"abstract-winston-transport": "^0.5.1",
+		"assume": "^2.2.0",
+		"cross-spawn-async": "^2.2.5",
+		"eslint": "^8.57.0",
+		"hock": "^1.4.1",
+		"jest": "^29.7.0",
+		"rimraf": "5.0.10",
+		"split2": "^4.1.0",
+		"std-mocks": "^2.0.0",
+		"through2": "^4.0.2",
+		"winston-compat": "^0.1.5"
+	},
+	"main": "./lib/winston.js",
+	"browser": "./dist/winston",
+	"types": "./index.d.ts",
+	"scripts": {
+		"lint": "eslint lib/*.js lib/winston/*.js lib/winston/**/*.js --resolve-plugins-relative-to ./node_modules/@dabh/eslint-config-populist",
+		"test": "jest",
+		"test:unit": "jest -c test/jest.config.unit.js",
+		"test:integration": "jest -c test/jest.config.integration.js",
+		"test:typescript": "npx --package typescript tsc --project test",
+		"build": "babel lib -d dist",
+		"prebuild": "rimraf dist",
+		"prepublishOnly": "npm run build"
+	},
+	"engines": {
+		"node": ">= 12.0.0"
+	},
+	"license": "MIT"
+}

package/dist/assets/package-Ceo2h27X.json

@@ -0,0 +1,89 @@
+{
+  "name": "@grpc/grpc-js",
+  "version": "1.14.3",
+  "description": "gRPC Library for Node - pure JS implementation",
+  "homepage": "https://grpc.io/",
+  "repository": "https://github.com/grpc/grpc-node/tree/master/packages/grpc-js",
+  "main": "build/src/index.js",
+  "engines": {
+    "node": ">=12.10.0"
+  },
+  "keywords": [],
+  "author": {
+    "name": "Google Inc."
+  },
+  "types": "build/src/index.d.ts",
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@grpc/proto-loader": "file:../proto-loader",
+    "@types/gulp": "^4.0.17",
+    "@types/gulp-mocha": "0.0.37",
+    "@types/lodash": "^4.14.202",
+    "@types/mocha": "^10.0.6",
+    "@types/ncp": "^2.0.8",
+    "@types/node": ">=20.11.20",
+    "@types/pify": "^5.0.4",
+    "@types/semver": "^7.5.8",
+    "@typescript-eslint/eslint-plugin": "^7.1.0",
+    "@typescript-eslint/parser": "^7.1.0",
+    "@typescript-eslint/typescript-estree": "^7.1.0",
+    "clang-format": "^1.8.0",
+    "eslint": "^8.42.0",
+    "eslint-config-prettier": "^8.8.0",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-prettier": "^4.2.1",
+    "execa": "^2.0.3",
+    "gulp": "^4.0.2",
+    "gulp-mocha": "^6.0.0",
+    "lodash": "^4.17.21",
+    "madge": "^5.0.1",
+    "mocha-jenkins-reporter": "^0.4.1",
+    "ncp": "^2.0.0",
+    "pify": "^4.0.1",
+    "prettier": "^2.8.8",
+    "rimraf": "^3.0.2",
+    "semver": "^7.6.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3"
+  },
+  "contributors": [
+    {
+      "name": "Google Inc."
+    }
+  ],
+  "scripts": {
+    "build": "npm run compile",
+    "clean": "rimraf ./build",
+    "compile": "tsc -p .",
+    "format": "clang-format -i -style=\"{Language: JavaScript, BasedOnStyle: Google, ColumnLimit: 80}\" src/*.ts test/*.ts",
+    "lint": "eslint src/*.ts test/*.ts",
+    "prepare": "npm run copy-protos && npm run generate-types && npm run generate-test-types && npm run compile",
+    "test": "gulp test",
+    "check": "npm run lint",
+    "fix": "eslint --fix src/*.ts test/*.ts",
+    "pretest": "npm run generate-types && npm run generate-test-types && npm run compile",
+    "posttest": "npm run check && madge -c ./build/src",
+    "generate-types": "proto-loader-gen-types --keepCase --longs String --enums String --defaults --oneofs --includeComments --includeDirs proto/ --include-dirs proto/ proto/xds/ proto/protoc-gen-validate/ -O src/generated/ --grpcLib ../index channelz.proto xds/service/orca/v3/orca.proto",
+    "generate-test-types": "proto-loader-gen-types --keepCase --longs String --enums String --defaults --oneofs --includeComments --include-dirs test/fixtures/ -O test/generated/ --grpcLib ../../src/index test_service.proto echo_service.proto",
+    "copy-protos": "node ./copy-protos"
+  },
+  "dependencies": {
+    "@grpc/proto-loader": "^0.8.0",
+    "@js-sdsl/ordered-map": "^4.4.2"
+  },
+  "files": [
+    "src/**/*.ts",
+    "build/src/**/*.{js,d.ts,js.map}",
+    "proto/**/*.proto",
+    "proto/**/LICENSE",
+    "LICENSE",
+    "deps/envoy-api/envoy/api/v2/**/*.proto",
+    "deps/envoy-api/envoy/config/**/*.proto",
+    "deps/envoy-api/envoy/service/**/*.proto",
+    "deps/envoy-api/envoy/type/**/*.proto",
+    "deps/udpa/udpa/**/*.proto",
+    "deps/googleapis/google/api/*.proto",
+    "deps/googleapis/google/rpc/*.proto",
+    "deps/protoc-gen-validate/validate/**/*.proto"
+  ]
+}

package/dist/assets/source_context-D0atuL28.json

@@ -0,0 +1,20 @@
+{
+  "nested": {
+    "google": {
+      "nested": {
+        "protobuf": {
+          "nested": {
+            "SourceContext": {
+              "fields": {
+                "fileName": {
+                  "type": "string",
+                  "id": 1
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/dist/assets/type-BFqO8SCZ.json

@@ -0,0 +1,202 @@
+{
+  "nested": {
+    "google": {
+      "nested": {
+        "protobuf": {
+          "nested": {
+            "Type": {
+              "fields": {
+                "name": {
+                  "type": "string",
+                  "id": 1
+                },
+                "fields": {
+                  "rule": "repeated",
+                  "type": "Field",
+                  "id": 2
+                },
+                "oneofs": {
+                  "rule": "repeated",
+                  "type": "string",
+                  "id": 3
+                },
+                "options": {
+                  "rule": "repeated",
+                  "type": "Option",
+                  "id": 4
+                },
+                "sourceContext": {
+                  "type": "SourceContext",
+                  "id": 5
+                },
+                "syntax": {
+                  "type": "Syntax",
+                  "id": 6
+                }
+              }
+            },
+            "Field": {
+              "fields": {
+                "kind": {
+                  "type": "Kind",
+                  "id": 1
+                },
+                "cardinality": {
+                  "type": "Cardinality",
+                  "id": 2
+                },
+                "number": {
+                  "type": "int32",
+                  "id": 3
+                },
+                "name": {
+                  "type": "string",
+                  "id": 4
+                },
+                "typeUrl": {
+                  "type": "string",
+                  "id": 6
+                },
+                "oneofIndex": {
+                  "type": "int32",
+                  "id": 7
+                },
+                "packed": {
+                  "type": "bool",
+                  "id": 8
+                },
+                "options": {
+                  "rule": "repeated",
+                  "type": "Option",
+                  "id": 9
+                },
+                "jsonName": {
+                  "type": "string",
+                  "id": 10
+                },
+                "defaultValue": {
+                  "type": "string",
+                  "id": 11
+                }
+              },
+              "nested": {
+                "Kind": {
+                  "values": {
+                    "TYPE_UNKNOWN": 0,
+                    "TYPE_DOUBLE": 1,
+                    "TYPE_FLOAT": 2,
+                    "TYPE_INT64": 3,
+                    "TYPE_UINT64": 4,
+                    "TYPE_INT32": 5,
+                    "TYPE_FIXED64": 6,
+                    "TYPE_FIXED32": 7,
+                    "TYPE_BOOL": 8,
+                    "TYPE_STRING": 9,
+                    "TYPE_GROUP": 10,
+                    "TYPE_MESSAGE": 11,
+                    "TYPE_BYTES": 12,
+                    "TYPE_UINT32": 13,
+                    "TYPE_ENUM": 14,
+                    "TYPE_SFIXED32": 15,
+                    "TYPE_SFIXED64": 16,
+                    "TYPE_SINT32": 17,
+                    "TYPE_SINT64": 18
+                  }
+                },
+                "Cardinality": {
+                  "values": {
+                    "CARDINALITY_UNKNOWN": 0,
+                    "CARDINALITY_OPTIONAL": 1,
+                    "CARDINALITY_REQUIRED": 2,
+                    "CARDINALITY_REPEATED": 3
+                  }
+                }
+              }
+            },
+            "Enum": {
+              "fields": {
+                "name": {
+                  "type": "string",
+                  "id": 1
+                },
+                "enumvalue": {
+                  "rule": "repeated",
+                  "type": "EnumValue",
+                  "id": 2
+                },
+                "options": {
+                  "rule": "repeated",
+                  "type": "Option",
+                  "id": 3
+                },
+                "sourceContext": {
+                  "type": "SourceContext",
+                  "id": 4
+                },
+                "syntax": {
+                  "type": "Syntax",
+                  "id": 5
+                }
+              }
+            },
+            "EnumValue": {
+              "fields": {
+                "name": {
+                  "type": "string",
+                  "id": 1
+                },
+                "number": {
+                  "type": "int32",
+                  "id": 2
+                },
+                "options": {
+                  "rule": "repeated",
+                  "type": "Option",
+                  "id": 3
+                }
+              }
+            },
+            "Option": {
+              "fields": {
+                "name": {
+                  "type": "string",
+                  "id": 1
+                },
+                "value": {
+                  "type": "Any",
+                  "id": 2
+                }
+              }
+            },
+            "Syntax": {
+              "values": {
+                "SYNTAX_PROTO2": 0,
+                "SYNTAX_PROTO3": 1
+              }
+            },
+            "Any": {
+              "fields": {
+                "type_url": {
+                  "type": "string",
+                  "id": 1
+                },
+                "value": {
+                  "type": "bytes",
+                  "id": 2
+                }
+              }
+            },
+            "SourceContext": {
+              "fields": {
+                "fileName": {
+                  "type": "string",
+                  "id": 1
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/dist/auth/headless-detect.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Detect if the current environment is headless (no browser available).
+ *
+ * Used to determine whether to use the PKCE localhost callback flow
+ * (desktop) or the RFC 8628 device authorization flow (headless/SSH).
+ *
+ * Checks in order:
+ * 1. SSH session (SSH_CLIENT, SSH_TTY)
+ * 2. CI environments (CI, GITHUB_ACTIONS, GITLAB_CI)
+ * 3. Container environments (container, DOCKER_CONTAINER)
+ * 4. Linux without display server (no DISPLAY and no WAYLAND_DISPLAY)
+ */
+export declare function isHeadless(): boolean;
+//# sourceMappingURL=headless-detect.d.ts.map

package/dist/auth/headless-detect.js

@@ -0,0 +1,25 @@
+import "../chunk-gOLHoazu.js";
+//#region src/auth/headless-detect.ts
+/**
+* Detect if the current environment is headless (no browser available).
+*
+* Used to determine whether to use the PKCE localhost callback flow
+* (desktop) or the RFC 8628 device authorization flow (headless/SSH).
+*
+* Checks in order:
+* 1. SSH session (SSH_CLIENT, SSH_TTY)
+* 2. CI environments (CI, GITHUB_ACTIONS, GITLAB_CI)
+* 3. Container environments (container, DOCKER_CONTAINER)
+* 4. Linux without display server (no DISPLAY and no WAYLAND_DISPLAY)
+*/
+function isHeadless() {
+	if (process.env.SSH_CLIENT || process.env.SSH_TTY) return true;
+	if (process.env.CI || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI) return true;
+	if (process.env.container || process.env.DOCKER_CONTAINER) return true;
+	if (process.platform === "linux" && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) return true;
+	return false;
+}
+//#endregion
+export { isHeadless };
+
+//# sourceMappingURL=headless-detect.js.map

package/dist/chunk-gOLHoazu.js

@@ -0,0 +1,4 @@
+import "node:module";
+import.meta.url;
+//#endregion
+export {};

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+import "./chunk-gOLHoazu.js";
+import { compileCommand } from "./commands/compile.js";
+import { watchCommand } from "./commands/watch.js";
+import { fixtureCommand } from "./commands/fixture.js";
+import { testCommand } from "./commands/test.js";
+import { runLocalCommand, runRemoteCommand } from "./commands/run.js";
+import { initCommand } from "./commands/init.js";
+import { hookInstallCommand } from "./commands/hook.js";
+import { loginCommand } from "./commands/login.js";
+import { secretsListCommand } from "./commands/secrets-list.js";
+import { statusCommand } from "./commands/status.js";
+import { typesCommand } from "./commands/types.js";
+import { endpointsCommand } from "./commands/endpoints.js";
+import { orgCurrentCommand, orgListCommand, orgUseCommand } from "./commands/org.js";
+import { logoutCommand } from "./commands/logout.js";
+import { cancelCommand } from "./commands/cancel.js";
+import { workflowsListCommand } from "./commands/workflows.js";
+import { drainWorkerCommand } from "./commands/drain-worker.js";
+import { docsCommand, docsLlmCommand } from "./commands/docs.js";
+import "./commands/index.js";
+import { Argument, Command, Option } from "commander";
+import pc from "picocolors";
+//#region src/cli.ts
+const version = typeof KICI_VERSION !== "undefined" ? KICI_VERSION : "0.0.1";
+const program = new Command();
+program.name("kici").description("KiCI workflow compiler").version(version);
+program.hook("preAction", () => {
+	console.log(pc.gray(`kici v${version}`));
+});
+program.configureOutput({ outputError: (str, write) => {
+	write(pc.red(str));
+} });
+program.command("compile").description("Compile workflows from .kici/workflows/ to kici.lock.json").option("--check", "Validate workflows without writing lock file", false).option("--kici-dir <path>", "Path to .kici directory", ".kici").option("--verbose", "Detailed output", false).option("--watch", "Watch for changes and recompile", false).action(async (options) => {
+	if (options.watch) await watchCommand({
+		kiciDir: options.kiciDir,
+		verbose: options.verbose
+	});
+	else {
+		const success = await compileCommand({
+			kiciDir: options.kiciDir,
+			check: options.check,
+			verbose: options.verbose
+		});
+		process.exit(success ? 0 : 1);
+	}
+});
+const fixtureEventArg = new Argument("<event>", "Event to generate fixture for (e.g., pr:open, push, schedule, lifecycle:workflow_complete)");
+program.command("fixture").addArgument(fixtureEventArg).description("Generate fixture template for event type").option("--output <path>", "Write to file instead of stdout").action(async (event, options) => {
+	await fixtureCommand(event, options);
+});
+const runCommand = program.command("run").description("Execute workflows locally or remotely");
+runCommand.command("local").argument("[event]", "Event type (e.g., push, pr:open, schedule) — optional with --pick").description("Execute workflows locally without orchestrator infrastructure").option("-p, --pick", "Interactively pick a workflow and trigger to simulate", false).option("--workflow <name>", "Run only the specified workflow").option("--job <name>", "Run only the specified job (and its dependencies)").option("--branch <name>", "Override detected git branch").option("--sha <hash>", "Override detected git SHA").option("--payload <path>", "Path to explicit event payload JSON file").option("--concurrency <n>", "Max parallel jobs (default: CPU cores)", parseInt).option("--keep-going", "Continue after job failure", false).option("--container", "Use Podman container isolation", false).option("--env <KEY=VALUE>", "Environment variable override (repeatable)", (val, prev) => [...prev, val], []).option("--quiet", "Suppress streaming output", false).option("--json", "Output structured JSON result", false).option("--junit <path>", "Output JUnit XML result").option("--files <path>", "Override changed file paths (repeatable, default: git diff)", (val, prev) => [...prev, val], []).option("--debug", "Verbose internals", false).option("--kici-dir <path>", "Path to .kici directory", ".kici").action(async (event, options) => {
+	if (options.pick && options.workflow) {
+		console.error("Error: --pick is mutually exclusive with --workflow.");
+		process.exit(2);
+	}
+	if (!options.pick && !event) {
+		console.error("Error: missing event argument. Pass an event or use --pick.");
+		process.exit(2);
+	}
+	const success = await runLocalCommand({
+		event,
+		pick: options.pick,
+		workflow: options.workflow,
+		job: options.job,
+		branch: options.branch,
+		sha: options.sha,
+		payload: options.payload,
+		concurrency: options.concurrency,
+		keepGoing: options.keepGoing,
+		container: options.container,
+		env: options.env,
+		quiet: options.quiet,
+		json: options.json,
+		junit: options.junit,
+		files: options.files,
+		debug: options.debug,
+		kiciDir: options.kiciDir
+	});
+	process.exit(success ? 0 : 1);
+});
+runCommand.command("remote").argument("[fixture]", "Fixture name or glob pattern (omit to list available)").description("Execute fixtures remotely via orchestrator").option("--workflow <name>", "Run a specific workflow directly (bypass triggers)").option("--all", "Run all available fixtures", false).option("--parallel", "Run matching fixtures concurrently", false).option("--no-wait", "Fire and forget (print runIds, don't stream)").option("--quiet", "Suppress output except final result", false).option("--json", "Output structured JSON result", false).option("--junit <path>", "Output JUnit XML result").option("--history", "Show recent run history", false).option("--routing-key <key>", "Override routing key for this run").option("--debug", "Verbose internals", false).option("--kici-dir <path>", "Path to .kici directory", ".kici").option("--secret <key=value>", "Inject flat secret (repeatable)", (val, prev) => [...prev, val], []).option("--context <ctx.key=value>", "Inject context secret (repeatable)", (val, prev) => [...prev, val], []).action(async (fixture, options) => {
+	const success = await runRemoteCommand(fixture, options);
+	process.exit(success ? 0 : 1);
+});
+program.command("test").argument("[event]", "Event type to preview (e.g., push, pr:open, schedule)").description("Preview which workflows match a trigger event (dry-run)").option("--branch <name>", "Override target branch for trigger matching (default: main)").option("--sha <hash>", "Override commit SHA").option("--workflow <name>", "Filter to specific workflow in display").option("--job <name>", "Filter to specific job in display").option("--debug", "Verbose internals", false).option("--kici-dir <path>", "Path to .kici directory", ".kici").option("--files <path>", "Simulate changed file path for trigger matching (repeatable)", (val, prev) => [...prev, val], []).option("--secret <key=value>", "Inject flat secret (repeatable)", (val, prev) => [...prev, val], []).option("--context <ctx.key=value>", "Inject context secret (repeatable)", (val, prev) => [...prev, val], []).action(async (event, options) => {
+	const success = await testCommand(event, options);
+	process.exit(success ? 0 : 1);
+});
+program.command("init").description("Initialize .kici/ directory with default workflows").option("--force", "Overwrite existing .kici/ directory", false).option("--skip-install", "Create files without running npm install", false).option("--mjs", "JavaScript-only mode (no TypeScript, no dependencies)", false).option("--no-agents-md", "Skip writing .kici/AGENTS.md (LLM authoring context)").option("--private-registry <url>", "Scaffold a workflow registries: entry pointing at <url>").option("--private-registry-scope <scope>", "Optional npm package scope (e.g. @my-org) for the private registry").option("--private-registry-secret <ref>", "Qualified secret reference (env:NAME) the private registry token comes from", "production:NPM_TOKEN").addOption(new Option("--use-verdaccio-local").default(false).hideHelp()).action(async (options) => {
+	const success = await initCommand({
+		...options,
+		noAgentsMd: options.agentsMd === false
+	});
+	process.exit(success ? 0 : 1);
+});
+program.command("hook").description("Manage pre-commit hooks").command("install").description("Install kici compile pre-commit hook").option("--git", "Use raw git hook (.git/hooks/pre-commit)", false).action(async (options) => {
+	const success = await hookInstallCommand({ git: options.git });
+	process.exit(success ? 0 : 1);
+});
+program.command("login").description("Authenticate with KiCI via browser OAuth (default) or API key (--token)").option("--token <key>", "API key for direct authentication (legacy)").option("--device", "Force device authorization flow (for headless/SSH environments)").option("--endpoint <url>", "Orchestrator URL for direct connection").option("--platform-endpoint <url>", "Platform relay URL").option("--routing-key <key>", "Routing key for webhook source identification").addHelpText("after", `
+Environment variables:
+  KICI_BROWSER_CMD     Custom browser command (use {url} placeholder, or 'none' to suppress)
+  KICI_CALLBACK_PORT   Fixed port for OAuth PKCE callback server (default: random)
+  KICI_CONFIG_DIR      Override config directory (default: ~/.kici)
+  KICI_OIDC_ISSUER     Override OIDC issuer URL
+  KICI_OIDC_CLIENT_ID  Override OIDC client ID
+`).action(async (options) => {
+	const success = await loginCommand({
+		token: options.token,
+		device: options.device,
+		endpoint: options.endpoint,
+		platformEndpoint: options.platformEndpoint,
+		routingKey: options.routingKey
+	});
+	process.exit(success ? 0 : 1);
+});
+program.command("logout").description("Revoke PAT and clear local credentials").action(async () => {
+	const success = await logoutCommand();
+	process.exit(success ? 0 : 1);
+});
+const orgCommand = program.command("org").description("Manage organizations");
+orgCommand.command("list").description("List organizations you belong to").action(async () => {
+	const success = await orgListCommand();
+	process.exit(success ? 0 : 1);
+});
+orgCommand.command("use").argument("<name>", "Organization name or ID").description("Switch active organization").action(async (name) => {
+	const success = await orgUseCommand(name);
+	process.exit(success ? 0 : 1);
+});
+orgCommand.command("current").description("Show current active organization").action(async () => {
+	const success = await orgCurrentCommand();
+	process.exit(success ? 0 : 1);
+});
+program.command("secrets").description("Manage secrets").command("list").description("List test-available secret contexts").option("--endpoint <url>", "Orchestrator URL override").action(async (options) => {
+	const success = await secretsListCommand({ endpoint: options.endpoint });
+	process.exit(success ? 0 : 1);
+});
+program.command("status").argument("<run-id>", "Run ID to inspect").description("Show status and details of a test run").option("--logs", "Stream full log replay", false).option("--job <name>", "Filter logs to specific job").option("--json", "Output raw JSON", false).action(async (runId, options) => {
+	const success = await statusCommand(runId, {
+		logs: options.logs,
+		job: options.job,
+		json: options.json
+	});
+	process.exit(success ? 0 : 1);
+});
+program.command("cancel").argument("[run-id]", "Run ID to cancel").description("Cancel a running workflow or all runs on a branch").option("--force", "Force cancel (kill immediately, skip hooks)", false).option("--branch <name>", "Cancel all in-progress runs on this branch").action(async (runId, options) => {
+	const success = await cancelCommand(runId, {
+		force: options.force,
+		branch: options.branch
+	});
+	process.exit(success ? 0 : 1);
+});
+program.command("types").description("Generate TypeScript declarations for secret contexts").option("--kici-dir <path>", "Path to .kici directory", ".kici").option("--endpoint <url>", "Orchestrator URL override").action(async (options) => {
+	const success = await typesCommand({
+		kiciDir: options.kiciDir,
+		endpoint: options.endpoint
+	});
+	process.exit(success ? 0 : 1);
+});
+program.command("endpoints").description("List all webhook entrypoints for the current project").option("--kici-dir <path>", "Path to .kici directory", ".kici").action(async (options) => {
+	const success = await endpointsCommand({ kiciDir: options.kiciDir });
+	process.exit(success ? 0 : 1);
+});
+program.command("workflows").description("Manage workflow registrations").command("list").description("List permanently registered workflows").option("--json", "Output as JSON", false).option("--stale <duration>", "Filter stale registrations (e.g., 30d, 7d)").option("--trigger-type <type>", "Filter by trigger type").option("--repo <repo>", "Filter by repository").action(async (options) => {
+	const success = await workflowsListCommand({
+		json: options.json,
+		stale: options.stale,
+		triggerType: options.triggerType,
+		repo: options.repo
+	});
+	process.exit(success ? 0 : 1);
+});
+program.command("docs").description("Open the KiCI documentation site in the default browser").option("--no-open", "Print the docs URL instead of opening a browser").action(async (options) => {
+	const success = await docsCommand({ open: options.open });
+	process.exit(success ? 0 : 1);
+}).command("llm").description("Print the bundled LLM context (llms-full.txt) to stdout").option("--index", "Print the curated llms.txt index instead of the full bundle", false).option("--out <path>", "Write the bundle to a file instead of stdout").action(async (options) => {
+	const success = await docsLlmCommand({
+		index: options.index,
+		out: options.out
+	});
+	process.exit(success ? 0 : 1);
+});
+program.command("admin").description("Operator-facing commands for running instances").command("drain-worker").description("Trigger graceful drain on a worker instance").requiredOption("--url <url>", "Worker URL (e.g., http://worker-host:<port>)").action(async (options) => {
+	const success = await drainWorkerCommand({ url: options.url });
+	process.exit(success ? 0 : 1);
+});
+program.parse();
+//#endregion
+export {};
+
+//# sourceMappingURL=cli.js.map

package/dist/commands/cancel.d.ts

@@ -0,0 +1,22 @@
+/**
+ * kici cancel command
+ *
+ * Cancels a specific run by ID, or all in-progress runs on a branch.
+ * Uses the Platform dashboard API (PAT auth) or orchestrator API (direct mode).
+ */
+/** Options for the cancel command */
+export interface CancelOptions {
+    /** Force cancel (SIGKILL, skip hooks) */
+    force?: boolean;
+    /** Cancel all in-progress runs on this branch */
+    branch?: string;
+}
+/**
+ * Cancel a run or all runs on a branch.
+ *
+ * @param runId - Run ID to cancel (optional if --branch is provided)
+ * @param options - Cancel options
+ * @returns true on success, false on error
+ */
+export declare function cancelCommand(runId: string | undefined, options?: CancelOptions): Promise<boolean>;
+//# sourceMappingURL=cancel.d.ts.map