@agimon-ai/doompi-core 0.0.1-alpha.100

package/dist/src/web/types/modelContext.d.mts

@@ -0,0 +1,43 @@
+//#region src/web/types/modelContext.d.ts
+/** The model-visible part of a WebMCP tool registration. */
+export interface ModelContextToolDescriptor {
+  readonly name: string;
+  readonly description: string;
+  readonly inputSchema: Readonly<Record<string, unknown>>;
+}
+export interface ModelContextAbortSignal {
+  readonly aborted: boolean;
+  readonly reason?: unknown;
+  addEventListener(type: 'abort', listener: () => void, options?: {
+    readonly once?: boolean;
+  }): void;
+  removeEventListener(type: 'abort', listener: () => void): void;
+}
+export interface ModelContextExecutionOptions {
+  readonly signal: ModelContextAbortSignal;
+}
+export interface ModelContextRegistrationOptions {
+  readonly signal: ModelContextAbortSignal;
+}
+/** A descriptor plus the page callback that implements it. */
+export interface ModelContextTool extends ModelContextToolDescriptor {
+  execute(input: string, options: ModelContextExecutionOptions): Promise<unknown>;
+}
+export interface ModelContextToolChangeEvent {
+  readonly type: 'toolchange';
+}
+export type ModelContextToolChangeListener = (event: ModelContextToolChangeEvent) => void;
+/** The common surface supplied by either the browser or DoomPi's simulator. */
+export interface ModelContext {
+  registerTool(tool: ModelContextTool, options: ModelContextRegistrationOptions): void | Promise<void>;
+  getTools(): Promise<readonly ModelContextToolDescriptor[]>;
+  executeTool(name: string, input: string, options: ModelContextExecutionOptions): Promise<unknown>;
+  addEventListener(type: 'toolchange', listener: ModelContextToolChangeListener): void;
+  removeEventListener(type: 'toolchange', listener: ModelContextToolChangeListener): void;
+}
+export interface ModelContextBinding {
+  readonly kind: 'native' | 'simulator';
+  readonly modelContext: ModelContext;
+}
+//#endregion
+//# sourceMappingURL=modelContext.d.mts.map

package/dist/src/web/types/modelContext.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modelContext.d.mts","names":[],"sources":["../../../../src/web/types/modelContext.ts"],"mappings":";;iBACiB;WACN;WACA;WACA,aAAa,SAAS;;iBAGhB;WACN;WACA;EACT,iBAAiB,eAAe,sBAAsB;aAAqB;;EAC3E,oBAAoB,eAAe;;iBAGpB;WACN,QAAQ;;iBAGF;WACN,QAAQ;;;iBAIF,yBAAyB;EACxC,QAAQ,eAAe,SAAS,+BAA+B;;iBAGhD;WACN;;YAGC,kCAAkC,OAAO;;iBAGpC;EACf,aAAa,MAAM,kBAAkB,SAAS,yCAAyC;EACvF,YAAY,iBAAiB;EAC7B,YAAY,cAAc,eAAe,SAAS,+BAA+B;EACjF,iBAAiB,oBAAoB,UAAU;EAC/C,oBAAoB,oBAAoB,UAAU;;iBAGnC;WACN;WACA,cAAc"}

package/dist/src/web/types/sessionRegistry.d.mts

@@ -0,0 +1,43 @@
+//#region src/web/types/sessionRegistry.d.ts
+/**
+ * Vocabulary for the on-disk session registry that the hub watches and every
+ * session server writes into.
+ *
+ * Session lineage rides a sidecar file rather than the session record itself.
+ * The record's schema is owned and written by the session server, so a package
+ * that spawns a session has no way to add a field to it. A sidecar written
+ * beside the record lets any spawning package declare where a session came
+ * from without either side reaching into the other's format, and lets a reader
+ * treat a missing or unreadable sidecar as "no parent" rather than an error.
+ */
+/** How a registry directory is chosen, most explicit source first. */
+export interface RegistryDirInput {
+  /** Value of --registry-dir, when given; wins over everything else. */
+  readonly flagValue?: string;
+  /** Value of DOOMPI_RUNTIME_DIR, when set. */
+  readonly envValue?: string;
+  /** The user's home directory, supplied by the host. */
+  readonly homeDir: string;
+}
+/**
+ * Where the cockpit hub is listening, published by the hub into the registry
+ * directory so a local process can find it without guessing ports.
+ *
+ * This is deliberately the local listener only. The hub may also be reachable
+ * through a tunnel, but that address is for people, not for processes on this
+ * machine, and writing it here would turn a discovery file into a way to reach
+ * a cockpit from somewhere its owner never authorised.
+ *
+ * Finding this file is not proof the hub is alive. It outlives a crash, so a
+ * reader probes the address before trusting it.
+ */
+export interface HubAdvertisement {
+  /** Bumped when this shape changes; a reader ignores any other value. */
+  version: 1;
+  /** Origin of the local listener, such as "http://127.0.0.1:4300". */
+  url: string;
+  /** The hub process, so a reader can tell a restart from a stale file. */
+  pid: number;
+}
+//#endregion
+//# sourceMappingURL=sessionRegistry.d.mts.map

package/dist/src/web/types/sessionRegistry.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionRegistry.d.mts","names":[],"sources":["../../../../src/web/types/sessionRegistry.ts"],"mappings":";;;;;;;;;;;;;iBAaiB;;WAEN;;WAEA;;WAEA;;;;;;;;;;;;;;iBAeM;;EAEf;;EAEA;;EAEA"}

package/dist/src/web/types/template.d.mts

@@ -0,0 +1,155 @@
+import { ComponentType, ReactNode, RefCallback } from "react";
+//#region src/web/types/template.d.ts
+/** Host content is independent of the selected presentation package. */
+export interface WebTemplateSlots {
+  header: (options: WebTemplateHeaderOptions) => ReactNode;
+  notices: ReactNode;
+  content: ReactNode;
+  composer: ReactNode;
+  controls: ReactNode;
+  activity: ReactNode;
+}
+/** A drawer-based template keeps the corresponding header controls visible on desktop too. */
+export interface WebTemplateHeaderOptions {
+  navigationToggle: 'mobile' | 'always';
+  activityToggle: 'mobile' | 'always';
+}
+/** A setup-only child reservation shown under its parent; it has no runtime of its own. */
+export interface WebTemplateRailPendingSetup {
+  id: string;
+  name: string;
+  /** Display copy such as "automatic worktree provisioning". */
+  status: string;
+  failed: boolean;
+  /** What to do next, present once a setup failed or was interrupted. */
+  recovery?: string;
+}
+/** One session card, with every value the host derives already computed. */
+export interface WebTemplateRailSession {
+  id: string;
+  name: string;
+  /** 1-based position across the whole rail; digits 1-9 focus it. */
+  ordinal: number;
+  active: boolean;
+  /** Rendered under its parent session: one fixed indent, never multiplied by depth. */
+  nested: boolean;
+  /** The spawning package's label for a nested session, such as "worktree". */
+  provenance?: string;
+  status: string;
+  awaitingInput: boolean;
+  restarting: boolean;
+  /** A failed restart; the template shows its own errors for actions it awaits. */
+  error?: string;
+  git?: {
+    branch: string;
+    dirty: boolean;
+  };
+  profile?: {
+    name: string;
+    /** Display name, falling back to the profile name. */
+    label: string;
+    initials: string;
+    /** Ready-to-render image URL; absent while loading or when the profile has no icon. */
+    avatarUrl?: string;
+  };
+  pendingSetups: readonly WebTemplateRailPendingSetup[];
+}
+export interface WebTemplateRailWorkspace {
+  id: string;
+  name: string;
+  root: string;
+  available: boolean;
+  /** Sessions recorded without a workspace; offers no create or workspace menu. */
+  legacy: boolean;
+  sessions: readonly WebTemplateRailSession[];
+}
+/** Resolves undefined on success, or the reason the action failed. */
+export type WebTemplateRailResult = Promise<{
+  error: string;
+} | undefined>;
+export interface WebTemplateRailDirectoryListing {
+  path: string;
+  parent?: string;
+  directories: readonly string[];
+}
+/** Everything the rail can ask the host to do. Actions that navigate also close a drawer rail. */
+export interface WebTemplateRailActions {
+  openSession: (sessionId: string) => void;
+  renameSession: (sessionId: string, name: string) => void;
+  restartSession: (sessionId: string) => void;
+  removeSession: (sessionId: string) => WebTemplateRailResult;
+  /** Opens the host's history dialog for one session. */
+  resumeSession: (sessionId: string) => void;
+  /** Opens the new-session dialog for a workspace: the host's, or a workspace plugin's `new-session` fill. */
+  createSession: (workspaceId: string) => void;
+  resumeInWorkspace: (workspaceId: string) => void;
+  openWorkspaceSettings: (workspaceId: string) => void;
+  deleteWorkspace: (workspaceId: string) => WebTemplateRailResult;
+  openAddWorkspace: () => void;
+  closeAddWorkspace: () => void;
+  /** Admits a folder, or with no path creates `~/.pi/.doom/workspace/<name>`. The host closes the dialog on success. */
+  addWorkspace: (input: {
+    name: string;
+    path?: string;
+  }) => WebTemplateRailResult;
+  searchDirectories: (query: string) => Promise<readonly string[]>;
+  /** Lists a folder's visible child directories; home when no path is given. */
+  listDirectory: (path?: string) => Promise<WebTemplateRailDirectoryListing | {
+    error: string;
+  }>;
+  removePendingSetup: (sessionId: string, setupId: string) => WebTemplateRailResult;
+  openSettings: () => void;
+  openRemoteAccess: () => void;
+  turnRemoteAccessOff: () => void;
+  /** Plugin menu items for a session; render first inside the session menu's content. */
+  renderSessionMenuItems: (sessionId: string) => ReactNode;
+}
+/**
+ * Session navigation data and actions. The template owns every piece of rail
+ * presentation; the host keeps state, shortcuts, and the dialogs that call their
+ * own APIs (new session, resume, remote access).
+ */
+export interface WebTemplateRail {
+  /** Host order; the legacy group, when present, is last. */
+  workspaces: readonly WebTemplateRailWorkspace[];
+  remote: {
+    status: 'off' | 'starting' | 'on' | 'failed';
+    host?: string;
+    deviceCount: number;
+    error?: string;
+  };
+  /** Plugin fills for the rail region. */
+  pluginContent: ReactNode;
+  /**
+   * Present while the add-workspace dialog is open. Render it at the layout root,
+   * never inside a drawer that can unmount while closed.
+   */
+  addWorkspace?: {
+    suggestedPaths: readonly string[];
+  };
+  /** Attach to the navigation scroller to preserve its position across scope remounts. */
+  scrollRef?: RefCallback<HTMLElement>;
+  actions: WebTemplateRailActions;
+}
+export interface WebTemplateProps {
+  view: 'conversation' | 'panel' | 'settings' | 'welcome';
+  slots: WebTemplateSlots;
+  /** Session navigation, rendered by the template. A template that ignores it simply shows no rail. */
+  rail: WebTemplateRail;
+  navigationOpen: boolean;
+  desktopActivityOpen: boolean;
+  mobileActivityOpen: boolean;
+  onNavigationOpenChange: (open: boolean) => void;
+  onDesktopActivityOpenChange: (open: boolean) => void;
+  onMobileActivityOpenChange: (open: boolean) => void;
+}
+/** A template is a browser contribution, never an agent mode or a separate session runtime. */
+export interface WebTemplateContribution {
+  id: string;
+  label: string;
+  description: string;
+  contractVersion: 1;
+  layout: ComponentType<WebTemplateProps>;
+}
+//#endregion
+//# sourceMappingURL=template.d.mts.map

package/dist/src/web/types/template.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template.d.mts","names":[],"sources":["../../../../src/web/types/template.ts"],"mappings":";;;iBAGiB;EACf,SAAS,SAAS,6BAA6B;EAC/C,SAAS;EACT,SAAS;EACT,UAAU;EACV,UAAU;EACV,UAAU;;;iBAIK;EACf;EACA;;;iBAIe;EACf;EACA;;EAEA;EACA;;EAEA;;;iBAIe;EACf;EACA;;EAEA;EACA;;EAEA;;EAEA;EACA;EACA;EACA;;EAEA;EACA;IAAQ;IAAgB;;EACxB;IACE;;IAEA;IACA;;IAEA;;EAEF,wBAAwB;;iBAGT;EACf;EACA;EACA;EACA;;EAEA;EACA,mBAAmB;;;YAIT,wBAAwB;EAAU;;iBAE7B;EACf;EACA;EACA;;;iBAIe;EACf,cAAc;EACd,gBAAgB,mBAAmB;EACnC,iBAAiB;EACjB,gBAAgB,sBAAsB;;EAEtC,gBAAgB;;EAEhB,gBAAgB;EAChB,oBAAoB;EACpB,wBAAwB;EACxB,kBAAkB,wBAAwB;EAC1C;EACA;;EAEA,eAAe;IAAS;IAAc;QAAoB;EAC1D,oBAAoB,kBAAkB;;EAEtC,gBAAgB,kBAAkB,QAAQ;IAAoC;;EAC9E,qBAAqB,mBAAmB,oBAAoB;EAC5D;EACA;EACA;;EAEA,yBAAyB,sBAAsB;;;;;;;iBAQhC;;EAEf,qBAAqB;EACrB;IAAU;IAA8C;IAAe;IAAqB;;;EAE5F,eAAe;;;;;EAKf;IAAiB;;;EAEjB,YAAY,YAAY;EACxB,SAAS;;iBAGM;EACf;EACA,OAAO;;EAEP,MAAM;EACN;EACA;EACA;EACA,yBAAyB;EACzB,8BAA8B;EAC9B,6BAA6B;;;iBAId;EACf;EACA;EACA;EACA;EACA,QAAQ,cAAc"}