@kici-dev/orchestrator 0.0.0 → 0.1.1

package/dist/cli/commands/backend.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Secret backend management commands for kici-admin.
+ *
+ * Provides subcommands for backend CRUD, connectivity testing, and sync:
+ *   backend add <name>    Register a new secret backend
+ *   backend remove <name> Remove a backend (with confirmation)
+ *   backend list          List all registered backends
+ *   backend test [name]   Test backend connectivity
+ *   backend sync [name]   Trigger scope discovery sync
+ *
+ * Credentials are read from environment variables or files (not shell args)
+ * per design decision.
+ */
+import type { Command } from 'commander';
+import type { AdminApiClient } from '../api-client.js';
+export declare function registerBackendCommands(program: Command, getClient: () => AdminApiClient): void;
+//# sourceMappingURL=backend.d.ts.map

package/dist/cli/commands/cold-store-impl.d.ts

@@ -0,0 +1,101 @@
+export declare function archiveNow(opts: {
+    databaseUrl: string;
+    table: string;
+    instanceId?: string;
+}): Promise<void>;
+export declare function dryRunArchive(opts: {
+    databaseUrl: string;
+    table: string;
+    tenant?: string;
+    from?: string;
+    to?: string;
+    instanceId?: string;
+}): Promise<void>;
+export interface ChunkListing {
+    chunkId: string;
+    tenantId: string;
+    partitionDate: string;
+    dataKey: string | null;
+    manifestKey: string | null;
+}
+export declare function listChunks(opts: {
+    databaseUrl: string;
+    table: string;
+    tenant?: string;
+    missingData?: boolean;
+    missingManifest?: boolean;
+    from?: string;
+    to?: string;
+    instanceId?: string;
+}): Promise<void>;
+export declare function verifyChunk(opts: {
+    databaseUrl: string;
+    chunkId: string;
+    table: string;
+    tenant: string;
+    partitionDate: string;
+    instanceId?: string;
+}): Promise<'match' | 'mismatch'>;
+export declare function replayChunk(opts: {
+    databaseUrl: string;
+    chunkId: string;
+    table: string;
+    tenant: string;
+    partitionDate: string;
+    instanceId?: string;
+}): Promise<void>;
+/**
+ * Phase F — promote a chunk's rows BACK into the orchestrator PG.
+ * Mirrors the Platform-side `replayIntoPg`. Adapter must implement
+ * `replayInsert` — currently only `execution_runs`.
+ */
+export declare function replayIntoPg(opts: {
+    databaseUrl: string;
+    chunkId: string;
+    table: string;
+    tenant: string;
+    partitionDate: string;
+    instanceId?: string;
+}): Promise<void>;
+export declare function reconcile(opts: {
+    databaseUrl: string;
+    table: string;
+    tenant?: string;
+    confirmCleanup?: boolean;
+    instanceId?: string;
+}): Promise<void>;
+/**
+ * Phase 2 — list chunks past their cold-retention horizon. Read-only;
+ * no S3 or PG mutation. Emits one JSON line per row so the output is
+ * easy to pipe through `jq` / `column -t` / etc.
+ */
+export declare function listPurgeable(opts: {
+    databaseUrl: string;
+    table?: string;
+    bucket?: string;
+    limit?: number;
+    instanceId?: string;
+}): Promise<void>;
+/**
+ * Phase 2 — delete S3 objects + clean up PG bookkeeping for chunks
+ * past their cold-retention horizon. Defaults to dry-run; pass
+ * `--apply` to actually delete.
+ */
+export declare function purgeNow(opts: {
+    databaseUrl: string;
+    table?: string;
+    bucket?: string;
+    limit?: number;
+    apply?: boolean;
+    instanceId?: string;
+}): Promise<void>;
+export declare function peekChunk(opts: {
+    databaseUrl: string;
+    chunkId: string;
+    table: string;
+    tenant: string;
+    partitionDate: string;
+    limit: number;
+    instanceId?: string;
+}): Promise<void>;
+//# sourceMappingURL=cold-store-impl.d.ts.map

package/dist/cli/commands/cold-store.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Cold-store commands for kici-admin (orchestrator side).
+ *
+ * Phase C: every subcommand has a real implementation that builds an
+ * `OrchestratorColdStore` against the orchestrator Postgres + S3 and
+ * delegates to the helpers in `cold-store-impl.ts`. Mirrors
+ * `kici-platform-admin cold-store …` on the Platform side.
+ *
+ *   cold-store archive-now <table>       Run one cycle for a single adapter
+ *   cold-store dry-run-archive <table>   Show what would be archived
+ *   cold-store list-chunks <table>       List chunks for a table
+ *   cold-store verify-chunk <chunkId>    Recompute contentHash for a chunk
+ *   cold-store replay-chunk <chunkId>    Re-run UPDATE+DELETE for a stuck chunk
+ *   cold-store reconcile <table>         Rebuild orphaned manifests from data
+ *   cold-store peek-chunk <chunkId>      Stream the first N rows of a chunk
+ *
+ * The CLI talks **directly** to the orchestrator Postgres (and the same
+ * S3 bucket the running process uses). It does not go through the
+ * orchestrator HTTP admin API — every operation here is a break-glass
+ * inspection of bytes that don't belong to the running process.
+ */
+import type { Command } from 'commander';
+import type { AdminApiClient } from '../api-client.js';
+/**
+ * @param _getClient unused — cold-store commands talk to the DB + S3
+ *   directly. Retained for signature consistency with other command
+ *   group registrations.
+ */
+export declare function registerColdStoreCommands(program: Command, _getClient: () => AdminApiClient): void;
+//# sourceMappingURL=cold-store.d.ts.map

package/dist/cli/commands/config.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Config management commands for kici-admin.
+ *
+ * Provides subcommands for orchestrator configuration management:
+ *   config seed, get, set, delete, export, validate, diff, history, rollback, reload, init
+ *
+ * All commands except `validate --offline` and `init` are thin clients over
+ * the admin REST API at /admin/config/*.
+ *
+ * Provider configuration (GitHub Apps, etc.) is managed via the `sources` table
+ * and the `kici-admin source` commands, not through config seed.
+ */
+import type { Command } from 'commander';
+import type { AdminApiClient } from '../api-client.js';
+export declare function registerConfigCommands(program: Command, getClient: () => AdminApiClient): void;
+//# sourceMappingURL=config.d.ts.map

package/dist/cli/commands/db.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Database management commands for kici-admin.
+ *
+ *   db migrate              Run pending migrations (HTTP — orchestrator must be up)
+ *   db fresh                DROP + CREATE + migrate + store content hash (direct DB)
+ *   db ensure <name>        CREATE DATABASE IF NOT EXISTS (direct DB)
+ *   db create-role          CREATE ROLE LOGIN [CREATEDB] (direct DB)
+ *   db create-readonly-user Read-only role + GRANT SELECT (direct DB)
+ *   db check-schema         Compare bundled migrations vs live schema (direct DB)
+ *
+ * The direct-DB subcommands cannot go through HTTP because the target database
+ * may not exist yet or is about to be dropped. They follow the same pattern
+ * as `kici-admin peer create-token` — open a pool from KICI_DATABASE_URL /
+ * DATABASE_URL / --database-url.
+ */
+import type { Command } from 'commander';
+import type { AdminApiClient } from '../api-client.js';
+export declare function registerDbCommands(program: Command, getClient: () => AdminApiClient): void;
+//# sourceMappingURL=db.d.ts.map

package/dist/cli/commands/debug-bundle.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Debug bundle CLI command for kici-admin.
+ *
+ * Creates a sanitized diagnostic ZIP bundle by calling multiple admin API
+ * endpoints and assembling the results client-side. The bundle contains
+ * config, diagnostics, system info, and cluster state for troubleshooting.
+ *
+ * Usage: kici-admin debug-bundle [--output <path>]
+ */
+import type { Command } from 'commander';
+import type { AdminApiClient } from '../api-client.js';
+/**
+ * Register the debug-bundle command on the CLI program.
+ */
+export declare function registerDebugBundleCommand(program: Command, getClient: () => AdminApiClient): void;
+//# sourceMappingURL=debug-bundle.d.ts.map

package/dist/cli/commands/diagnose.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Diagnostic health check command for kici-admin.
+ *
+ * Calls the orchestrator's /admin/diagnose endpoint and displays
+ * results as a formatted table or raw JSON.
+ *
+ * Exit codes:
+ *   0 - all checks pass
+ *   1 - any check warns
+ *   2 - any check fails
+ */
+import type { Command } from 'commander';
+import type { AdminApiClient } from '../api-client.js';
+export declare function registerDiagnoseCommand(program: Command, getClient: () => AdminApiClient): void;
+//# sourceMappingURL=diagnose.d.ts.map

package/dist/cli/commands/environment.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Environment management CLI commands for kici-admin.
+ *
+ *   environment create         — upsert an environment
+ *   environment bind           — bind a scope pattern to an environment
+ *   environment set-policy     — update policy fields (branch, reviewers, timers, trust)
+ *   environment list           — list environments for an org
+ *   environment show           — show a single environment with variables + bindings
+ *   environment create-template — create/update an environment template + its seed variables
+ *
+ * Each command supports two modes (stage-4 pattern from `maintenance.ts`):
+ *
+ *   HTTP mode (default): requires `--url` + `--token`, routes through the
+ *   orchestrator admin HTTP API at /api/v1/admin/environments.
+ *
+ *   Direct-DB mode: activated when `--database-url` is passed (or
+ *   KICI_DATABASE_URL / DATABASE_URL is set). Opens its own pool and runs the
+ *   SQL directly via *Direct helpers in @kici-dev/shared. Used by E2E
+ *   `globalSetup` helpers that need to seed envs before the orchestrator is up.
+ */
+import type { Command } from 'commander';
+import type { AdminApiClient } from '../api-client.js';
+export declare function registerEnvironmentCommands(program: Command, getClient: () => AdminApiClient): void;
+//# sourceMappingURL=environment.d.ts.map

package/dist/cli/commands/event-dlq.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Event DLQ admin CLI commands for kici-admin.
+ *
+ *   event-dlq list     — list events in the DLQ
+ *   event-dlq count    — total DLQ depth
+ *   event-dlq retry <id>     — clear DLQ flag, schedule for retry, pg_notify
+ *   event-dlq discard <id>   — permanently delete a DLQ event
+ *
+ * Operator dogfooding path for at-least-once event delivery (Phase 5 of the
+ * event durability work). Customers should generally never see anything in
+ * the DLQ — when something lands here it usually means a workflow handler is
+ * consistently failing and should be fixed at its root cause. This CLI is the
+ * triage surface: inspect last_error, retry once a fix is deployed, or discard
+ * if the event is no longer relevant.
+ */
+import type { Command } from 'commander';
+import type { AdminApiClient } from '../api-client.js';
+export declare function registerEventDlqCommands(program: Command, getClient: () => AdminApiClient): void;
+//# sourceMappingURL=event-dlq.d.ts.map

package/dist/cli/commands/event-log.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Inbound webhook delivery log commands for kici-admin.
+ *
+ * Operator-facing read access to the orchestrator's event_log table via the
+ * admin HTTP API. Dogfood replacement for raw psql / log-grep when an
+ * operator asks "did delivery <id> arrive, and what did its payload look
+ * like".
+ *
+ *   event-log list   List inbound deliveries with filters
+ *   event-log show   Show a single delivery (optionally with payload)
+ *
+ * Filter flags for `list`:
+ *   --org             -> ?orgId=
+ *   --routing-key     -> ?routingKey=
+ *   --event           -> ?event=
+ *   --action          -> ?action=
+ *   --status          -> ?status=
+ *   --from            -> ?from= (ISO timestamp)
+ *   --to              -> ?to=   (ISO timestamp)
+ *   --delivery-id     -> ?deliveryId= (substring)
+ *   --limit / --offset
+ *   --json            Emit raw JSON
+ */
+import type { Command } from 'commander';
+import type { AdminApiClient } from '../api-client.js';
+export declare function registerEventLogCommands(program: Command, getClient: () => AdminApiClient): void;
+//# sourceMappingURL=event-log.d.ts.map

package/dist/cli/commands/event.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from 'commander';
+import type { AdminApiClient } from '../api-client.js';
+export declare function registerEventCommands(program: Command, getClient: () => AdminApiClient): void;
+//# sourceMappingURL=event.d.ts.map

package/dist/cli/commands/execution.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Execution read CLI commands for kici-admin.
+ *
+ *   execution list [--routing-key <k>] [--status <s>] [--workflow-name <n>] [--limit <n>]
+ *   execution show <runId>
+ *
+ * READ-ONLY — mutations (purge-stale) live in `maintenance.ts` instead.
+ * Dual-mode: HTTP (via AdminApiClient) or `--database-url` (direct DB).
+ *
+ * supersedes the original `cache list|show` framing: the real tables
+ * the E2E call sites touch are execution_runs / execution_jobs, not
+ * dedup_cache.
+ */
+import type { Command } from 'commander';
+import type { AdminApiClient } from '../api-client.js';
+export declare function registerExecutionCommands(program: Command, getClient: () => AdminApiClient): void;
+//# sourceMappingURL=execution.d.ts.map

package/dist/cli/commands/inspect-bundle.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Inspect-bundle CLI command for kici-admin.
+ *
+ * Parses a previously-created debug bundle ZIP and displays a structured
+ * summary with colorized output. Works fully offline -- no running
+ * orchestrator or network access needed.
+ *
+ * Usage: kici-admin inspect-bundle <path>
+ */
+import type { Command } from 'commander';
+/**
+ * Register the inspect-bundle command on the CLI program.
+ * No getClient needed -- this command works fully offline.
+ */
+export declare function registerInspectBundleCommand(program: Command): void;
+//# sourceMappingURL=inspect-bundle.d.ts.map

package/dist/cli/commands/maintenance.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from 'commander';
+import type { AdminApiClient } from '../api-client.js';
+export declare function registerMaintenanceCommands(program: Command, getClient: () => AdminApiClient): void;
+//# sourceMappingURL=maintenance.d.ts.map

package/dist/cli/commands/orchestrator-service/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Orchestrator service command group registration.
+ *
+ * Registers `kici-admin orchestrator` with install, uninstall, start, stop,
+ * restart, status, logs, and upgrade subcommands for managing the orchestrator
+ * as a system service.
+ *
+ * These commands manage local services directly and do NOT use AdminApiClient.
+ */
+import type { Command } from 'commander';
+export declare function registerOrchestratorServiceCommands(program: Command): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/commands/orchestrator-service/install.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `kici-admin orchestrator install` command.
+ *
+ * Registers the orchestrator as a native system service on the current platform.
+ * Auto-detects platform and privilege level, creates config directories,
+ * writes env file, and registers the service with the init system.
+ */
+import type { Command } from 'commander';
+export declare function registerOrchestratorInstall(orchestrator: Command): void;
+//# sourceMappingURL=install.d.ts.map

package/dist/cli/commands/orchestrator-service/logs.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `kici-admin orchestrator logs` command.
+ *
+ * Tails and follows service logs with filtering by time, level,
+ * and output format. Delegates to the platform-specific service
+ * manager's logs() method.
+ */
+import type { Command } from 'commander';
+export declare function registerLogsCommand(parent: Command): void;
+//# sourceMappingURL=logs.d.ts.map

package/dist/cli/commands/orchestrator-service/restart.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `kici-admin orchestrator restart` command.
+ *
+ * Restarts the orchestrator service.
+ */
+import type { Command } from 'commander';
+export declare function registerOrchestratorRestart(orchestrator: Command): void;
+//# sourceMappingURL=restart.d.ts.map

package/dist/cli/commands/orchestrator-service/start.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `kici-admin orchestrator start` command.
+ *
+ * Starts the orchestrator service.
+ */
+import type { Command } from 'commander';
+export declare function registerOrchestratorStart(orchestrator: Command): void;
+//# sourceMappingURL=start.d.ts.map

package/dist/cli/commands/orchestrator-service/status.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `kici-admin orchestrator status` command.
+ *
+ * Shows OS-level service status (state, PID, uptime) and queries
+ * the running orchestrator's health API for KiCI-specific info
+ * (mode, DB connectivity, agents, jobs, scaler).
+ */
+import type { Command } from 'commander';
+export declare function registerStatusCommand(parent: Command): void;
+//# sourceMappingURL=status.d.ts.map

package/dist/cli/commands/orchestrator-service/stop.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `kici-admin orchestrator stop` command.
+ *
+ * Stops the orchestrator service.
+ */
+import type { Command } from 'commander';
+export declare function registerOrchestratorStop(orchestrator: Command): void;
+//# sourceMappingURL=stop.d.ts.map

package/dist/cli/commands/orchestrator-service/uninstall.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `kici-admin orchestrator uninstall` command.
+ *
+ * Removes the orchestrator service registration.
+ * Preserves config files, database, and logs per user decision.
+ */
+import type { Command } from 'commander';
+export declare function registerOrchestratorUninstall(orchestrator: Command): void;
+//# sourceMappingURL=uninstall.d.ts.map

package/dist/cli/commands/orchestrator-service/upgrade.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `kici-admin orchestrator upgrade` command.
+ *
+ * Upgrades the orchestrator using the versioned directory layout:
+ * - Extracts new version alongside old versions
+ * - Updates symlink (Unix) or service registration (Windows) atomically
+ * - Preserves old versions for rollback
+ * - Supports --cleanup and --rollback flags
+ */
+import type { Command } from 'commander';
+export declare function registerUpgradeCommand(parent: Command): void;
+//# sourceMappingURL=upgrade.d.ts.map

package/dist/cli/commands/org-settings.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Org-settings management commands for kici-admin.
+ *
+ * Subcommand namespace: `kici-admin org-settings global-workflows <subcommand>`.
+ *
+ * Talks to the orchestrator admin API directly (not the Platform dashboard
+ * proxy), so the CLI stays operable even when Platform is unavailable. Backed
+ * by `packages/orchestrator/src/routes/admin-org-settings.ts`.
+ *
+ * The settings row is org-scoped (one row per `customer_id`). Each pattern
+ * entry can optionally pin a webhook source via `--source <routingKey>`.
+ * Omitting `--source` stores the entry as "any source in the org".
+ */
+import type { Command } from 'commander';
+import type { AdminApiClient } from '../api-client.js';
+export declare function registerOrgSettingsCommands(program: Command, getClient: () => AdminApiClient): void;
+//# sourceMappingURL=org-settings.d.ts.map

package/dist/cli/commands/peer.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Peer management commands for kici-admin.
+ *
+ * Provides admin operations for peer token and credential management:
+ *   peer create-token   Create a join token for a new peer
+ *   peer list           List active peer credentials
+ *   peer revoke         Revoke a specific peer's credential
+ *   peer revoke-all     Revoke all peer credentials
+ */
+import type { Command } from 'commander';
+import type { AdminApiClient } from '../api-client.js';
+export declare function registerPeerCommands(program: Command, _getClient: () => AdminApiClient): void;
+//# sourceMappingURL=peer.d.ts.map

package/dist/cli/commands/queue.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Queue read CLI commands for kici-admin.
+ *
+ *   queue list [--status <s>] [--job-name-prefix <p>] [--limit <n>]
+ *   queue show <id>
+ *
+ * READ-ONLY — mutations live in `maintenance.ts` (queue clear) instead.
+ * Dual-mode: HTTP (via AdminApiClient) or `--database-url` (direct DB).
+ *
+ * supersedes the original `cache list|show` framing — the E2E call
+ * sites were actually querying dispatch_queue, not a dedup cache.
+ */
+import type { Command } from 'commander';
+import type { AdminApiClient } from '../api-client.js';
+export declare function registerQueueCommands(program: Command, getClient: () => AdminApiClient): void;
+//# sourceMappingURL=queue.d.ts.map

package/dist/cli/commands/registration.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Workflow registration read CLI commands for kici-admin (5a #4).
+ *
+ *   registration list [--org <id>] [--routing-key <k>] [--repo <ident>] [--limit <n>]
+ *   registration show <id>
+ *
+ * A distinct namespace from `workflow list` — `workflow` is workflow-code,
+ * `registration` is the registered-workflow-instance row in
+ * workflow_registrations. Both coexist; the existing `workflow list` is
+ * untouched by this plan.
+ *
+ * Dual-mode: HTTP (via AdminApiClient on the existing
+ * /api/v1/admin/registrations admin API) or `--database-url` (direct DB).
+ */
+import type { Command } from 'commander';
+import type { AdminApiClient } from '../api-client.js';
+export declare function registerRegistrationCommands(program: Command, getClient: () => AdminApiClient): void;
+//# sourceMappingURL=registration.d.ts.map

package/dist/cli/commands/rotate.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Key rotation command for kici-admin.
+ *
+ * Re-encrypts all PG-stored secrets with the current master key.
+ */
+import type { Command } from 'commander';
+import type { AdminApiClient } from '../api-client.js';
+export declare function registerRotateCommand(program: Command, getClient: () => AdminApiClient): void;
+//# sourceMappingURL=rotate.d.ts.map

package/dist/cli/commands/runs.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Execution run commands for kici-admin.
+ *
+ * Provides operator-facing read access to execution runs and their
+ * sub-resources via the orchestrator's admin HTTP API. This is the
+ * dogfooded replacement for hand-rolled curl commands when inspecting
+ * run state.
+ *
+ *   runs list                          List execution runs (table or JSON)
+ *   runs show <runId>                  Show run detail with jobs and steps
+ *   runs jobs <runId>                  List jobs for a run (optional steps)
+ *   runs ephemeral-key <runId>         Show scrub status of the run's key
+ *   runs secret-outputs <runId>        List secret outputs (masked / reveal)
+ *
+ * Filter flags for `runs list`:
+ *   --status            -> ?status=<csv>  (comma-separated, e.g. success,failed)
+ *   --workflow-name     -> ?workflowName=<name>
+ *   --repo              -> ?repo=<owner/repo>
+ *   --since             -> ?since=<ISO-8601>
+ *   --count             -> ?count=true    (emits only the count)
+ *   --limit             -> ?limit=<n>     (default 20, max 100)
+ *   --offset            -> ?offset=<n>    (default 0)
+ *
+ * Output:
+ *   default             Aligned ASCII table
+ *   --json              Raw JSON.stringify of the full response
+ */
+import type { Command } from 'commander';
+import type { AdminApiClient } from '../api-client.js';
+/**
+ * Register the `runs` command group with kici-admin.
+ */
+export declare function registerRunsCommands(program: Command, getClient: () => AdminApiClient): void;
+//# sourceMappingURL=runs.d.ts.map

package/dist/cli/commands/secret.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Secret management commands for kici-admin.
+ *
+ * Provides scoped secret operations:
+ *   secret scopes, list, set, delete
+ *
+ * Secret values are write-only -- there is no "get value" command.
+ */
+import type { Command } from 'commander';
+import type { AdminApiClient } from '../api-client.js';
+export declare function registerSecretCommands(program: Command, getClient: () => AdminApiClient): void;
+//# sourceMappingURL=secret.d.ts.map

package/dist/cli/commands/shared/db.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Shared database helper for CLI commands that need direct DB access.
+ *
+ * Provides a withDb() wrapper that creates a database connection from
+ * KICI_DATABASE_URL, runs a callback, and ensures cleanup.
+ */
+import pg from 'pg';
+import { Kysely } from 'kysely';
+/**
+ * Execute a callback with a database connection, then clean up.
+ *
+ * Reads the database URL from KICI_DATABASE_URL.
+ * Creates a connection pool, runs the callback, and destroys the pool.
+ */
+export declare function withDb<T>(fn: (db: Kysely<any>, pool: pg.Pool) => Promise<T>): Promise<T>;
+//# sourceMappingURL=db.d.ts.map

package/dist/cli/commands/shared/versioned-upgrade.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Shared versioned directory upgrade logic for kici-admin upgrade commands.
+ *
+ * Implements the versioned directory layout:
+ * - Extract new version alongside old versions
+ * - Update symlink (Unix) or service registration (Windows) atomically
+ * - Preserve old versions for rollback
+ * - Optional cleanup of old versions
+ */
+import { type ServicePlatform } from '../../service/index.js';
+/** Component types that can be upgraded. */
+type UpgradeComponent = 'orchestrator' | 'agent';
+/** Options for the versioned upgrade command. */
+interface VersionedUpgradeOptions {
+    platform?: ServicePlatform;
+    name: string;
+    from?: string;
+    url?: string;
+    version?: string;
+    yes?: boolean;
+    cleanup?: boolean;
+    rollback?: boolean;
+    force?: boolean;
+}
+/**
+ * Perform a versioned directory upgrade for a KiCI component.
+ *
+ * Flow:
+ * 1. Parse upgrade source (--from archive or --url)
+ * 2. Determine install base by platform
+ * 3. Extract new versioned directory
+ * 4. Stop service
+ * 5. Update symlink (Unix) or service registration (Windows)
+ * 6. Start service
+ */
+export declare function performVersionedUpgrade(component: UpgradeComponent, opts: VersionedUpgradeOptions): Promise<void>;
+export {};
+//# sourceMappingURL=versioned-upgrade.d.ts.map