dsh-live-teams 0.1.0

package/lib/migrations.d.ts

@@ -0,0 +1,17 @@
+//#region src/migrations.d.ts
+/**
+ * Bringing stored state forward.
+ *
+ * Every state file carries a `schemaVersion`. Reading already tolerates an older one — the fields
+ * that exist are the fields the reader knows — but nothing *brings it forward*: a field added in a
+ * later version would simply be missing until something happened to write the file again, and no
+ * record said the state had been read at an older version. A version from the future was refused with
+ * a bare "invalid state", which reads like corruption rather than "this was written by a newer DSH".
+ *
+ * A migration is a pure function from one version to the next. They are registered here by the
+ * version they migrate *from*, so the chain is explicit and testable; the list is empty today because
+ * version 1 is the first, and the framework exists so the first real change is a two-line addition
+ * rather than a redesign.
+ */
+export type Migration = (state: unknown) => unknown;
+//#endregion

package/lib/migrations.js

@@ -0,0 +1,47 @@
+import { ERROR_CODES, LiveTeamsError } from "./errors.js";
+//#region src/migrations.ts
+const MIGRATIONS = Object.freeze({});
+/**
+* What has to happen to read this state. `future` is a refusal with both numbers in it: a state
+* written by a newer product is not corruption, and saying so is the difference between a person
+* updating DSH and a person hunting a bug that is not there.
+*/
+function planMigration(stored, current, what, migrations = MIGRATIONS) {
+	if (!Number.isInteger(stored) || stored < 0) return {
+		kind: "future",
+		error: new LiveTeamsError(ERROR_CODES.STATE_CORRUPT, `${what} has no usable schemaVersion: ${String(stored)}`)
+	};
+	const from = stored;
+	if (from === current) return { kind: "current" };
+	if (from > current) return {
+		kind: "future",
+		error: new LiveTeamsError(ERROR_CODES.SCHEMA_UNSUPPORTED, `${what} was written by a newer DSH (schema ${from}, this build understands ${current}); update DSH rather than editing the state`)
+	};
+	const steps = [];
+	for (let version = from; version < current; version += 1) {
+		if (migrations[version] === void 0) return {
+			kind: "future",
+			error: new LiveTeamsError(ERROR_CODES.SCHEMA_UNSUPPORTED, `${what} is at schema ${from} and no migration from ${version} to ${version + 1} is registered; this build cannot read it`)
+		};
+		steps.push(version);
+	}
+	return {
+		kind: "migrate",
+		from,
+		to: current,
+		steps
+	};
+}
+/** Run the plan's steps in order. Returns the state as the current version sees it. */
+function applyMigration(state, plan, migrations = MIGRATIONS) {
+	if (plan.kind !== "migrate") return state;
+	let working = state;
+	for (const step of plan.steps) {
+		const migration = migrations[step];
+		if (migration === void 0) throw new LiveTeamsError(ERROR_CODES.SCHEMA_UNSUPPORTED, `migration from ${step} to ${step + 1} disappeared while it was running`);
+		working = migration(working);
+	}
+	return working;
+}
+//#endregion
+export { MIGRATIONS, applyMigration, planMigration };

package/lib/plugin.d.ts

@@ -0,0 +1,106 @@
+import { MailboxService } from "./mailbox.js";
+import { MemberRecord, TeamStore } from "./team-store.js";
+import { TaskStore } from "./task-store.js";
+import { ReconcileResult } from "./dispatch.js";
+import { SessionBridge, createSessionBridge } from "./session-bridge.js";
+import { SessionCommandQueue } from "./command-queue.js";
+import { MembershipContextProvider } from "./context-provider.js";
+import { LiveTeamsDispatch, LiveTeamsWebServer } from "./routes.js";
+import { ToolRuntime } from "@deepseek-ai/dsh-tools";
+//#region src/plugin.d.ts
+export declare const name = "live-teams-host";
+export declare const inject: readonly ["sessionController", "sessions", "agents", "systemPrompt", "workspaceRegistry"];
+type WorkspaceEntry = {
+  readonly path: string;
+  readonly id: string;
+  readonly title?: unknown;
+  readonly sessionIds?: readonly unknown[];
+};
+type AgentRegistry = {
+  readonly get?: (sessionId: string) => unknown;
+  readonly isOwnedBy?: (sessionId: string, owner: unknown) => boolean;
+};
+type NativePathController = {
+  readonly canOpenWorkspacePath?: () => boolean | Promise<boolean>;
+  readonly openWorkspacePath?: (request: {
+    path: string;
+    action: 'reveal' | 'open';
+  }, signal: AbortSignal) => Promise<unknown>;
+};
+type HostContext = {
+  effect: (effect: () => (() => void), name?: string) => void;
+  workspaceRegistry?: {
+    list?: () => WorkspaceEntry[];
+  };
+  tools?: Pick<ToolRuntime, 'register'>;
+  /** Optional service lookup: returns undefined instead of failing without inject. */
+  get?: (name: string) => unknown;
+  sessionController: Parameters<typeof createSessionBridge>[0]['controller'] & NativePathController;
+  agents?: AgentRegistry;
+  systemPrompt: {
+    context: (definition: ReturnType<MembershipContextProvider['definition']>) => unknown;
+  };
+  provide: (key: string, value: LiveTeamsService) => unknown;
+  logger?: {
+    warn?: (message: string) => void;
+  };
+  settingsController?: {
+    canOpenAgentPresetDirectory?: () => boolean | Promise<boolean>;
+  };
+  webServer?: LiveTeamsWebServer;
+  inject?: (deps: readonly string[], callback: (ctx: HostContext & {
+    webServer: LiveTeamsWebServer;
+  }) => void) => unknown;
+};
+export type PluginConfig = {
+  enabled?: boolean;
+  workspacePath?: string;
+  workspaceId?: string;
+  teamId?: string;
+  teamName?: string; /** How often the dispatcher sweeps as a safety net; a signal wakes it sooner. */
+  dispatchSweepMs?: number; /**
+   * Whether the dispatcher may start *coding* work on its own. `manual` (the default)
+   * keeps this product inside design §22, where the isolation it asked for is unavailable on this
+   * host (ADR 0008 is rejected): research
+   * and documentation tasks are dispatched, code is not. It is a deployment flag, not
+   * a team switch, because Gate C is a property of the product rather than of a team.
+   */
+  codingDispatch?: 'manual' | 'automatic'; /** Shared hotspots, on top of the built-in list (B30). */
+  sharedPaths?: string[];
+  /**
+   * B32: how the scope record observes the workspace. `auto` uses git in a work tree and a
+   * tree fingerprint otherwise, so a folder that is not a repository is a first-class case.
+   * The explicit values exist for a repository whose status is unusable, and for verifying
+   * the fingerprint path inside a repository.
+   */
+  scopeMode?: 'auto' | 'git' | 'files';
+};
+export type LiveTeamsService = {
+  teamId: string;
+  workspacePath: string;
+  bridge: SessionBridge;
+  queue: SessionCommandQueue;
+  mailbox: MailboxService;
+  contextProvider: MembershipContextProvider;
+  store: () => Promise<TeamStore>;
+  taskStore: () => Promise<TaskStore>;
+  /** The dispatch projection: what the reconciler would do, and why (B29). */
+  readDispatch: () => Promise<LiveTeamsDispatch>;
+  /** Run one reconcile pass now instead of waiting for a signal or the sweep. */
+  reconcile: (trigger?: string) => Promise<ReconcileResult>;
+  openMember: (sessionId: string) => Promise<MemberRecord | undefined>;
+  bindMember: (request: {
+    memberId: string;
+    sessionId: string;
+    expectedRevision: number;
+  }) => Promise<MemberRecord>;
+  readonly disposing: boolean;
+};
+/**
+ * Mount one host instance.  The optional workspacePath is a deliberate pin:
+ * with a pin the old single-workspace route shape is retained, while without it
+ * every request is resolved through its Session's cwd.
+ */
+export declare function apply(ctx: HostContext, config?: PluginConfig): void;
+//#endregion
+export { apply as default };