@kici-dev/compiler 0.1.27 → 0.3.0

package/dist/remote/dashboard-client.d.ts

@@ -4,7 +4,7 @@
  * only place in the CLI that knows these routes.
  */
 import { z } from 'zod';
-import { type RunListResponse, type RunListItem, type DiagnosticsInfrastructureResponse, type DiagnosticsSummaryResponse, type DashboardRunDetailApiResponse, type DashboardStepLogsApiResponse, type RegistrationItem } from '@kici-dev/engine';
+import { type ArtifactListItem, type RunListResponse, type RunListItem, type DiagnosticsInfrastructureResponse, type DiagnosticsSummaryResponse, type DashboardRunDetailApiResponse, type DashboardStepLogsApiResponse, type RegistrationItem } from '@kici-dev/engine';
 import { type GlobalConfig } from './config.js';
 export type DashboardErrorKind = 'not_logged_in' | 'no_active_org' | 'unauthorized' | 'forbidden' | 'not_found' | 'conflict' | 'cooldown' | 'orchestrator_offline' | 'http';
 /** Typed error raised by every DashboardClient method on a non-2xx response. */
@@ -22,8 +22,21 @@ export interface RunsListFilters {
     trigger?: string;
     source?: string;
     since?: string;
-    page?: number;
+    /** Opaque keyset cursor (from a prior page's `nextCursor`). Absent = first page. */
+    cursor?: string;
 }
+export declare const webhookActivitySchema: z.ZodObject<{
+    windowMinutes: z.ZodNumber;
+    received: z.ZodNumber;
+    delivered: z.ZodNumber;
+    edgeRejected: z.ZodNumber;
+    failed: z.ZodNumber;
+    matched: z.ZodOptional<z.ZodNumber>;
+    unmatched: z.ZodOptional<z.ZodNumber>;
+    lockfileMissing: z.ZodOptional<z.ZodNumber>;
+    orchestratorUnavailable: z.ZodBoolean;
+}, z.core.$strip>;
+export type WebhookActivity = z.infer<typeof webhookActivitySchema>;
 /** Result of {@link DashboardClient.listRegistrations}. */
 export interface RegistrationsListResult {
     registrations: RegistrationItem[];
@@ -48,6 +61,14 @@ declare const contextContextSchema: z.ZodObject<{
 }, z.core.$strip>;
 /** A secret context (context) returned by {@link DashboardClient.listContexts}. */
 export type ContextContext = z.infer<typeof contextContextSchema>;
+/**
+ * Parsed shape of `GET /runs/:runId/artifacts` for the CLI. The per-artifact
+ * shape is reused from `@kici-dev/engine` so the CLI and the server cannot drift.
+ */
+export interface ArtifactsListResult {
+    artifacts: ArtifactListItem[];
+    downloadUrlExpiresInSeconds?: number;
+}
 export declare class DashboardClient {
     private readonly endpoint;
     private readonly token;
@@ -62,17 +83,33 @@ export declare class DashboardClient {
     getJson(path: string): Promise<unknown>;
     /** Generic POST helper used by typed methods (and tests). */
     postJson(path: string, body?: unknown): Promise<unknown>;
+    /** Generic DELETE helper used by typed methods (and tests). */
+    deleteJson(path: string): Promise<unknown>;
     getDiagnosticsSummary(): Promise<DiagnosticsSummaryResponse>;
     getInfrastructure(): Promise<DiagnosticsInfrastructureResponse>;
     listRuns(filters?: RunsListFilters): Promise<RunListResponse>;
     getRun(runId: string): Promise<RunListItem>;
+    /**
+     * Fetch the org's recent webhook-activity counts. Returns null on ANY error
+     * (older Platform without the route, a network blip, an unexpected shape) so
+     * the `kici runs` empty-window hint degrades silently to today's output — the
+     * hint is a nicety, never a hard dependency.
+     */
+    getWebhookActivity(windowMinutes?: number): Promise<WebhookActivity | null>;
     getRunDetail(runId: string): Promise<DashboardRunDetailApiResponse>;
     getStepLogs(runId: string, jobId: string, stepIndex: number): Promise<DashboardStepLogsApiResponse>;
+    /**
+     * List a run's artifacts (`GET /runs/:runId/artifacts`). Each entry carries a
+     * presigned `downloadUrl` minted by the customer's orchestrator; the Platform
+     * relays it without re-signing, so the artifact bytes never transit Platform.
+     */
+    listArtifacts(runId: string): Promise<ArtifactsListResult>;
     rerunRun(runId: string): Promise<{
         newRunId: string;
     }>;
     cancelRun(runId: string, force: boolean): Promise<{
         cancelledJobs?: number;
+        alreadyTerminal?: boolean;
     }>;
     cancelByBranch(branch: string): Promise<{
         cancelledRuns?: number;

package/dist/remote/dashboard-client.js

@@ -1,6 +1,6 @@
 import "../rolldown-runtime-ClRpJifh.js";
 import { loadGlobalConfig } from "./config.js";
-import { dashboardRunDetailApiResponseSchema, dashboardStepLogsApiResponseSchema, diagnosticsInfrastructureResponseSchema, diagnosticsSummaryResponseSchema, registrationItemSchema, runListItemSchema, runListResponseSchema } from "@kici-dev/engine";
+import { artifactListItemSchema, dashboardRunDetailApiResponseSchema, dashboardStepLogsApiResponseSchema, diagnosticsInfrastructureResponseSchema, diagnosticsSummaryResponseSchema, registrationItemSchema, runListItemSchema, runListResponseSchema } from "@kici-dev/engine";
 import { z } from "zod";
 //#region src/remote/dashboard-client.ts
 /**
@@ -20,8 +20,22 @@ var DashboardClientError = class extends Error {
 	}
 };
 const singleRunSchema = z.object({ run: runListItemSchema });
+const webhookActivitySchema = z.object({
+	windowMinutes: z.number(),
+	received: z.number(),
+	delivered: z.number(),
+	edgeRejected: z.number(),
+	failed: z.number(),
+	matched: z.number().optional(),
+	unmatched: z.number().optional(),
+	lockfileMissing: z.number().optional(),
+	orchestratorUnavailable: z.boolean()
+});
 const rerunResponseSchema = z.object({ newRunId: z.string() });
-const cancelResponseSchema = z.object({ cancelledJobs: z.number().optional() });
+const cancelResponseSchema = z.object({
+	cancelledJobs: z.number().optional(),
+	alreadyTerminal: z.boolean().optional()
+});
 const cancelByBranchResponseSchema = z.object({ cancelledRuns: z.number().optional() });
 const registrationsListSchema = z.object({
 	registrations: z.array(registrationItemSchema).default([]),
@@ -40,6 +54,10 @@ const contextContextSchema = z.object({
 	secretKeys: z.array(z.string()).default([])
 });
 const contextsListSchema = z.object({ contexts: z.array(contextContextSchema).default([]) });
+const artifactsListResultSchema = z.object({
+	artifacts: z.array(artifactListItemSchema),
+	downloadUrlExpiresInSeconds: z.number().int().positive().optional()
+});
 const STATUS_ERROR_MAP = {
 	401: ["unauthorized", "Authentication failed. Run `kici login` to re-authenticate."],
 	403: ["forbidden", "Access denied."],
@@ -105,6 +123,10 @@ var DashboardClient = class DashboardClient {
 	async postJson(path, body) {
 		return this.request("POST", path, body);
 	}
+	/** Generic DELETE helper used by typed methods (and tests). */
+	async deleteJson(path) {
+		return this.request("DELETE", path);
+	}
 	async getDiagnosticsSummary() {
 		return diagnosticsSummaryResponseSchema.parse(await this.getJson("/diagnostics"));
 	}
@@ -120,19 +142,40 @@ var DashboardClient = class DashboardClient {
 		if (filters.trigger) qs.set("triggerType", filters.trigger);
 		if (filters.source) qs.set("source", filters.source);
 		if (filters.since) qs.set("since", filters.since);
-		if (filters.page) qs.set("page", String(filters.page));
+		if (filters.cursor) qs.set("cursor", filters.cursor);
 		const suffix = qs.toString() ? `?${qs.toString()}` : "";
 		return runListResponseSchema.parse(await this.getJson(`/runs${suffix}`));
 	}
 	async getRun(runId) {
 		return singleRunSchema.parse(await this.getJson(`/runs/${runId}`)).run;
 	}
+	/**
+	* Fetch the org's recent webhook-activity counts. Returns null on ANY error
+	* (older Platform without the route, a network blip, an unexpected shape) so
+	* the `kici runs` empty-window hint degrades silently to today's output — the
+	* hint is a nicety, never a hard dependency.
+	*/
+	async getWebhookActivity(windowMinutes = 60) {
+		try {
+			return webhookActivitySchema.parse(await this.getJson(`/webhook-activity?windowMinutes=${windowMinutes}`));
+		} catch {
+			return null;
+		}
+	}
 	async getRunDetail(runId) {
 		return dashboardRunDetailApiResponseSchema.parse(await this.getJson(`/runs/${runId}/detail`));
 	}
 	async getStepLogs(runId, jobId, stepIndex) {
 		return dashboardStepLogsApiResponseSchema.parse(await this.getJson(`/runs/${runId}/jobs/${jobId}/steps/${stepIndex}/logs`));
 	}
+	/**
+	* List a run's artifacts (`GET /runs/:runId/artifacts`). Each entry carries a
+	* presigned `downloadUrl` minted by the customer's orchestrator; the Platform
+	* relays it without re-signing, so the artifact bytes never transit Platform.
+	*/
+	async listArtifacts(runId) {
+		return artifactsListResultSchema.parse(await this.getJson(`/runs/${runId}/artifacts`));
+	}
 	async rerunRun(runId) {
 		return rerunResponseSchema.parse(await this.postJson(`/runs/${runId}/rerun`));
 	}
@@ -163,6 +206,6 @@ var DashboardClient = class DashboardClient {
 	}
 };
 //#endregion
-export { DashboardClient, DashboardClientError };
+export { DashboardClient, DashboardClientError, webhookActivitySchema };
 
 //# sourceMappingURL=dashboard-client.js.map

package/dist/remote/fs-case.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Report whether `dir` lives on a filesystem that ignores case in path lookups.
+ *
+ * Case sensitivity is a property of the mounted filesystem, not of the platform
+ * — a Linux host can mount a case-insensitive volume and macOS can format a
+ * case-sensitive one — so it is measured rather than inferred: an empty file is
+ * written under a random name and the same name is stat'd upper-cased. The
+ * directory is created if it is missing, and the probe file is removed on every
+ * path, including a throw.
+ *
+ * Rejects whenever the probe cannot produce an answer: the probe file cannot be
+ * written, or the twin lookup fails for any reason other than the twin's
+ * absence. Only `ENOENT` means "case-sensitive" — a permission or I/O error says
+ * nothing about case folding, and reporting it as case-sensitive would let a
+ * colliding set overwrite itself, so it is surfaced to the caller instead.
+ *
+ * It is its own module so callers can be tested against both answers with a
+ * cross-module spy, rather than against whatever filesystem the test runs on.
+ */
+export declare function isCaseInsensitiveDir(dir: string): Promise<boolean>;
+//# sourceMappingURL=fs-case.d.ts.map

package/dist/remote/fs-case.js

@@ -0,0 +1,45 @@
+import "../rolldown-runtime-ClRpJifh.js";
+import { join } from "node:path";
+import { mkdir, rm, stat, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+//#region src/remote/fs-case.ts
+/** Filesystem case-sensitivity probe for a target output directory. */
+/**
+* Report whether `dir` lives on a filesystem that ignores case in path lookups.
+*
+* Case sensitivity is a property of the mounted filesystem, not of the platform
+* — a Linux host can mount a case-insensitive volume and macOS can format a
+* case-sensitive one — so it is measured rather than inferred: an empty file is
+* written under a random name and the same name is stat'd upper-cased. The
+* directory is created if it is missing, and the probe file is removed on every
+* path, including a throw.
+*
+* Rejects whenever the probe cannot produce an answer: the probe file cannot be
+* written, or the twin lookup fails for any reason other than the twin's
+* absence. Only `ENOENT` means "case-sensitive" — a permission or I/O error says
+* nothing about case folding, and reporting it as case-sensitive would let a
+* colliding set overwrite itself, so it is surfaced to the caller instead.
+*
+* It is its own module so callers can be tested against both answers with a
+* cross-module spy, rather than against whatever filesystem the test runs on.
+*/
+async function isCaseInsensitiveDir(dir) {
+	await mkdir(dir, { recursive: true });
+	const probe = `.kici-case-probe-${randomUUID()}`;
+	const twin = probe.toUpperCase();
+	const probePath = join(dir, probe);
+	await writeFile(probePath, "");
+	try {
+		await stat(join(dir, twin));
+		return true;
+	} catch (err) {
+		if (err?.code === "ENOENT") return false;
+		throw err;
+	} finally {
+		await rm(probePath, { force: true });
+	}
+}
+//#endregion
+export { isCaseInsensitiveDir };
+
+//# sourceMappingURL=fs-case.js.map

package/dist/remote/history.d.ts

@@ -5,8 +5,7 @@
  * can review past runs (kici run remote --history) and inspect specific runs
  * (kici status <run-id>).
  */
-/** Status of a test run */
-type RunStatus = 'queued' | 'running' | 'success' | 'failed' | 'cancelled';
+import { type CanonicalStatus } from '@kici-dev/engine';
 /** A single run history entry */
 export interface HistoryEntry {
     /** Unique run identifier */
@@ -14,7 +13,7 @@ export interface HistoryEntry {
     /** Fixture that was run */
     fixtureId: string;
     /** Current status of the run */
-    status: RunStatus;
+    status: CanonicalStatus;
     /** ISO timestamp when the run started */
     startedAt: string;
     /** ISO timestamp when the run completed (if finished) */
@@ -87,5 +86,12 @@ export declare class RunHistory {
      */
     private save;
 }
+/** The plain (uncoloured) width of a status cell, for column padding. */
+export declare function statusLabelWidth(status: string): number;
+/**
+ * Format a run status with its colour and short label. A status this CLI does
+ * not recognise — a history file written by a newer version — renders verbatim.
+ */
+export declare function formatStatus(status: string): string;
 export {};
 //# sourceMappingURL=history.d.ts.map

package/dist/remote/history.js

@@ -5,6 +5,7 @@ import path from "node:path";
 import pc from "picocolors";
 import fs from "node:fs/promises";
 import { formatDuration } from "@kici-dev/core";
+import { ExecutionJobStatus, ExecutionRunStatus, toCanonicalStatus } from "@kici-dev/engine";
 import picomatch from "picomatch";
 //#region src/remote/history.ts
 /**
@@ -95,7 +96,8 @@ var RunHistory = class {
 		for (const entry of entries) {
 			const id = entry.runId.padEnd(idWidth);
 			const fixture = entry.fixtureId.padEnd(fixtureWidth);
-			const status = formatStatus(entry.status).padEnd(12);
+			const statusPad = Math.max(0, 12 - statusLabelWidth(entry.status));
+			const status = formatStatus(entry.status) + " ".repeat(statusPad);
 			const duration = entry.durationMs ? formatDuration(entry.durationMs).padEnd(12) : "-".padEnd(12);
 			const started = formatRelativeTime(entry.startedAt);
 			lines.push(`${id}${fixture}${status}${duration}${started}`);
@@ -129,18 +131,85 @@ var RunHistory = class {
 	}
 };
 /**
-* Format a run status with appropriate color and symbol.
+* Short label and colour for every canonical status in the run-history table.
+*
+* Exhaustive by type, so a new engine status breaks this file's typecheck
+* rather than making the history table print the literal string `undefined`.
+*
+* `label` and `color` are stored separately so the table's column width can be
+* measured on the plain label: padding a colour-wrapped string measures the
+* ANSI escape bytes too, which silently collapses the column.
 */
-function formatStatus(status) {
-	switch (status) {
-		case "success": return pc.green("pass");
-		case "failed": return pc.red("fail");
-		case "cancelled": return pc.yellow("cancel");
-		case "running": return pc.blue("running");
-		case "queued": return pc.gray("queued");
+const STATUS_DISPLAY = Object.freeze({
+	[ExecutionRunStatus.enum.success]: {
+		label: "pass",
+		color: pc.green
+	},
+	[ExecutionRunStatus.enum.failed]: {
+		label: "fail",
+		color: pc.red
+	},
+	[ExecutionJobStatus.enum.timed_out_stale]: {
+		label: "timeout",
+		color: pc.red
+	},
+	[ExecutionJobStatus.enum.drift_dropped]: {
+		label: "dropped",
+		color: pc.red
+	},
+	[ExecutionJobStatus.enum.unroutable]: {
+		label: "unroutable",
+		color: pc.red
+	},
+	[ExecutionRunStatus.enum.cancelled]: {
+		label: "cancel",
+		color: pc.yellow
+	},
+	[ExecutionRunStatus.enum.cancelling]: {
+		label: "cancelling",
+		color: pc.yellow
+	},
+	[ExecutionJobStatus.enum.recovering]: {
+		label: "recovering",
+		color: pc.yellow
+	},
+	[ExecutionRunStatus.enum.held]: {
+		label: "held",
+		color: pc.yellow
+	},
+	[ExecutionRunStatus.enum.running]: {
+		label: "running",
+		color: pc.blue
+	},
+	[ExecutionJobStatus.enum.queued]: {
+		label: "queued",
+		color: pc.dim
+	},
+	[ExecutionRunStatus.enum.pending]: {
+		label: "pending",
+		color: pc.dim
+	},
+	[ExecutionJobStatus.enum.skipped]: {
+		label: "skipped",
+		color: pc.dim
 	}
+});
+/** The plain (uncoloured) width of a status cell, for column padding. */
+function statusLabelWidth(status) {
+	const canonical = toCanonicalStatus(status.toLowerCase());
+	return canonical === void 0 ? status.length : STATUS_DISPLAY[canonical].label.length;
+}
+/**
+* Format a run status with its colour and short label. A status this CLI does
+* not recognise — a history file written by a newer version — renders verbatim.
+*/
+function formatStatus(status) {
+	const canonical = toCanonicalStatus(status.toLowerCase());
+	if (canonical === void 0) return pc.gray(status);
+	const { label, color } = STATUS_DISPLAY[canonical];
+	return color(label);
 }
 //#endregion
-export { RunHistory };
+export { RunHistory, formatStatus, statusLabelWidth };
 
 //# sourceMappingURL=history.js.map

package/dist/remote/local-repo-identity.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 /** Git hosts whose origin URL we can turn into a real `owner/repo` + web link. */
 export declare const RecognizedProvider: z.ZodEnum<{
+    bitbucket: "bitbucket";
     github: "github";
     gitlab: "gitlab";
-    bitbucket: "bitbucket";
 }>;
 export type RecognizedProvider = z.infer<typeof RecognizedProvider>;
 /** The literal provider value stamped when no recognized git origin exists. */

package/dist/remote/local-repo-identity.js

@@ -29,7 +29,8 @@ function parseGitOrigin(url) {
 	const urlStyle = /^[a-z]+:\/\/(?:[^@/]+@)?([^/]+)\/(.+?)(?:\.git)?$/.exec(trimmed);
 	const match = scp ?? urlStyle;
 	if (!match) return null;
-	const provider = HOST_PROVIDER[match[1].toLowerCase()];
+	const host = match[1].toLowerCase();
+	const provider = HOST_PROVIDER[host];
 	if (!provider) return null;
 	const repoIdentifier = match[2].replace(/^\/+|\/+$/g, "");
 	if (!repoIdentifier.includes("/")) return null;

package/dist/remote/notifications-client.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Typed client for the Platform's org-scoped notification API — the routes the
+ * dashboard Notifications tab uses (channels, subscriptions, and the Layer 1
+ * Slack-identity roster). Authenticated with the stored PAT + active org,
+ * exactly like {@link DashboardClient}, and reachable programmatically via the
+ * `kici notifications …` CLI.
+ *
+ * It composes a {@link DashboardClient} (same auth / org-scoped-URL / error
+ * mapping) rather than re-implementing the transport: every path here is
+ * relative to `/api/v1/orgs/:orgId/notifications/…`.
+ */
+import { z } from 'zod';
+import { DashboardClientError } from './dashboard-client.js';
+/**
+ * Notification protocol enums mirrored from the hosted Platform's notification
+ * route contract. The public `kici` CLI cannot import the private Platform
+ * package, so these values are re-declared here and reused across the client,
+ * the command arg parsing, and their tests (the single source of truth on the
+ * CLI side).
+ */
+export declare const NotificationChannelKind: z.ZodEnum<{
+    email: "email";
+    slack: "slack";
+}>;
+export type NotificationChannelKind = z.infer<typeof NotificationChannelKind>;
+export declare const NotificationSubLevel: z.ZodEnum<{
+    job: "job";
+    run: "run";
+}>;
+export type NotificationSubLevel = z.infer<typeof NotificationSubLevel>;
+export declare const NotificationScopeKind: z.ZodEnum<{
+    actor: "actor";
+    org: "org";
+    team: "team";
+    user: "user";
+}>;
+export type NotificationScopeKind = z.infer<typeof NotificationScopeKind>;
+export declare const RosterSubjectKind: z.ZodEnum<{
+    email: "email";
+    git_login: "git_login";
+    kici_user: "kici_user";
+}>;
+export type RosterSubjectKind = z.infer<typeof RosterSubjectKind>;
+export declare const RosterInputForm: z.ZodEnum<{
+    email: "email";
+    id: "id";
+    username: "username";
+}>;
+export type RosterInputForm = z.infer<typeof RosterInputForm>;
+/** A notification channel row as returned by the channels list route. */
+export interface NotificationChannel {
+    id: string;
+    type: string;
+    name: string;
+    managed?: boolean;
+    created_at?: string;
+}
+/** A notification subscription row as returned by the subscriptions list route. */
+export interface NotificationSubscription {
+    id: string;
+    level: string;
+    channel_id: string;
+    scope_type: string;
+    scope_id: string | null;
+    on_status: string[];
+    repo_glob: string | null;
+    workflow_glob: string | null;
+    job_glob: string | null;
+    mentions: string[] | null;
+    accumulate_for: number | null;
+    enabled: boolean;
+    source: string;
+}
+/** A Slack-identity roster row as returned by the roster list route. */
+export interface SlackIdentity {
+    id: string;
+    connection_id: string;
+    subject_kind: string;
+    subject_value: string;
+    slack_member_id: string;
+    input_form: string;
+    status: string;
+}
+/** Body for creating a Slack channel. */
+export interface CreateSlackChannelBody {
+    type: 'slack';
+    connection_id: string;
+    slack_channel_id: string;
+    name: string;
+}
+/** Body for creating an email channel. */
+export interface CreateEmailChannelBody {
+    type: 'email';
+    name: string;
+    from_name?: string;
+    reply_to?: string;
+}
+export type CreateChannelBody = CreateSlackChannelBody | CreateEmailChannelBody;
+/** Body for creating a subscription (mirrors the Platform create route schema). */
+export interface CreateSubscriptionBody {
+    level: NotificationSubLevel;
+    channel_id: string;
+    scope_type: NotificationScopeKind;
+    scope_id?: string | null;
+    on_status: string[];
+    repo_glob?: string | null;
+    workflow_glob?: string | null;
+    job_glob?: string | null;
+    mentions?: string[] | null;
+    recipient_override?: string[] | null;
+    on_failure_class?: string[] | null;
+    accumulate_for?: number | null;
+}
+/** Body for adding a roster identity (mirrors the Platform add route schema). */
+export interface AddIdentityBody {
+    connection_id: string;
+    subject_kind: RosterSubjectKind;
+    subject_value: string;
+    input_form: RosterInputForm;
+    value: string;
+}
+/**
+ * PAT + org-scoped client for the notification routes. Construct via
+ * {@link NotificationsClient.load}, which reads `~/.kici/config` and resolves
+ * the target org (`--org` override or the saved active org).
+ */
+export declare class NotificationsClient {
+    private readonly dashboard;
+    private constructor();
+    /**
+     * Load the authenticated client. `opts.org` overrides the saved active org
+     * for this invocation; otherwise the saved `activeOrgId` is used. Throws a
+     * {@link DashboardClientError} when the PAT / endpoint / org is missing.
+     */
+    static load(opts?: {
+        org?: string;
+    }): Promise<NotificationsClient>;
+    listChannels(): Promise<NotificationChannel[]>;
+    createChannel(body: CreateChannelBody): Promise<NotificationChannel>;
+    deleteChannel(id: string): Promise<void>;
+    listSubscriptions(): Promise<NotificationSubscription[]>;
+    createSubscription(body: CreateSubscriptionBody): Promise<NotificationSubscription>;
+    deleteSubscription(id: string): Promise<void>;
+    listIdentities(): Promise<SlackIdentity[]>;
+    addIdentity(body: AddIdentityBody): Promise<SlackIdentity>;
+    deleteIdentity(id: string): Promise<void>;
+}
+export { DashboardClientError };
+//# sourceMappingURL=notifications-client.d.ts.map

package/dist/remote/notifications-client.js

@@ -0,0 +1,103 @@
+import "../rolldown-runtime-ClRpJifh.js";
+import { loadGlobalConfig } from "./config.js";
+import { DashboardClient, DashboardClientError } from "./dashboard-client.js";
+import { z } from "zod";
+//#region src/remote/notifications-client.ts
+/**
+* Typed client for the Platform's org-scoped notification API — the routes the
+* dashboard Notifications tab uses (channels, subscriptions, and the Layer 1
+* Slack-identity roster). Authenticated with the stored PAT + active org,
+* exactly like {@link DashboardClient}, and reachable programmatically via the
+* `kici notifications …` CLI.
+*
+* It composes a {@link DashboardClient} (same auth / org-scoped-URL / error
+* mapping) rather than re-implementing the transport: every path here is
+* relative to `/api/v1/orgs/:orgId/notifications/…`.
+*/
+/**
+* Notification protocol enums mirrored from the hosted Platform's notification
+* route contract. The public `kici` CLI cannot import the private Platform
+* package, so these values are re-declared here and reused across the client,
+* the command arg parsing, and their tests (the single source of truth on the
+* CLI side).
+*/
+const NotificationChannelKind = z.enum(["slack", "email"]);
+const NotificationSubLevel = z.enum(["run", "job"]);
+const NotificationScopeKind = z.enum([
+	"org",
+	"team",
+	"user",
+	"actor"
+]);
+const RosterSubjectKind = z.enum([
+	"kici_user",
+	"git_login",
+	"email"
+]);
+const RosterInputForm = z.enum([
+	"id",
+	"username",
+	"email"
+]);
+const rowSchema = z.record(z.string(), z.unknown());
+const channelsListSchema = z.object({ channels: z.array(rowSchema).default([]) });
+const subscriptionsListSchema = z.object({ subscriptions: z.array(rowSchema).default([]) });
+const identitiesListSchema = z.object({ identities: z.array(rowSchema).default([]) });
+/**
+* PAT + org-scoped client for the notification routes. Construct via
+* {@link NotificationsClient.load}, which reads `~/.kici/config` and resolves
+* the target org (`--org` override or the saved active org).
+*/
+var NotificationsClient = class NotificationsClient {
+	dashboard;
+	constructor(dashboard) {
+		this.dashboard = dashboard;
+	}
+	/**
+	* Load the authenticated client. `opts.org` overrides the saved active org
+	* for this invocation; otherwise the saved `activeOrgId` is used. Throws a
+	* {@link DashboardClientError} when the PAT / endpoint / org is missing.
+	*/
+	static async load(opts = {}) {
+		const config = await loadGlobalConfig();
+		const effective = opts.org ? {
+			...config,
+			activeOrgId: opts.org
+		} : config;
+		return new NotificationsClient(DashboardClient.fromConfig(effective));
+	}
+	async listChannels() {
+		const { channels } = channelsListSchema.parse(await this.dashboard.getJson("notifications/channels"));
+		return channels;
+	}
+	async createChannel(body) {
+		return await this.dashboard.postJson("notifications/channels", body);
+	}
+	async deleteChannel(id) {
+		await this.dashboard.deleteJson(`notifications/channels/${encodeURIComponent(id)}`);
+	}
+	async listSubscriptions() {
+		const { subscriptions } = subscriptionsListSchema.parse(await this.dashboard.getJson("notifications/subscriptions"));
+		return subscriptions;
+	}
+	async createSubscription(body) {
+		return await this.dashboard.postJson("notifications/subscriptions", body);
+	}
+	async deleteSubscription(id) {
+		await this.dashboard.deleteJson(`notifications/subscriptions/${encodeURIComponent(id)}`);
+	}
+	async listIdentities() {
+		const { identities } = identitiesListSchema.parse(await this.dashboard.getJson("notifications/slack/identities"));
+		return identities;
+	}
+	async addIdentity(body) {
+		return await this.dashboard.postJson("notifications/slack/identities", body);
+	}
+	async deleteIdentity(id) {
+		await this.dashboard.deleteJson(`notifications/slack/identities/${encodeURIComponent(id)}`);
+	}
+};
+//#endregion
+export { DashboardClientError, NotificationChannelKind, NotificationScopeKind, NotificationSubLevel, NotificationsClient, RosterInputForm, RosterSubjectKind };
+
+//# sourceMappingURL=notifications-client.js.map