claude-code-session-manager 0.19.0 → 0.20.1

package/src/preload/api.d.ts

@@ -452,10 +452,6 @@ export interface ListConversationsResult {
   scannedMs: number;
 }
 
-export interface ProjectSkillState {
-  skillId: string;
-  enabled: boolean;
-}
 
 export interface FileEntry {
   name: string;
@@ -786,6 +782,39 @@ export interface SuperAgentStateChangedEvent {
   state: SuperAgentRunState | null;
 }
 
+// ────────────────────────────────────────────── Web Remote (PRD 08)
+
+export interface WebRemoteDevice {
+  deviceId: string;
+  deviceName: string;
+  issuedAt: string;
+  lastConnectedAt: string | null;
+}
+
+export interface WebRemoteStatus {
+  enabled: boolean;
+  connected: boolean;
+  e2eActive: boolean;
+  devices: WebRemoteDevice[];
+}
+
+export interface WebRemotePairResult {
+  ok: boolean;
+  deviceId?: string;
+  error?: string;
+}
+
+export interface WebRemoteMutationResult {
+  ok: boolean;
+  error?: string;
+}
+
+export interface WebRemoteAuditTailResult {
+  ok: boolean;
+  lines?: string[];
+  error?: string;
+}
+
 export interface SessionManagerAPI {
   app: {
     version: () => Promise<string>;
@@ -894,10 +923,6 @@ export interface SessionManagerAPI {
     status: () => Promise<OtelStatus>;
     configPath: () => Promise<string>;
   };
-  projectSkills: {
-    get: (cwd: string) => Promise<ProjectSkillState[]>;
-    set: (cwd: string, skillId: string, enabled: boolean) => Promise<{ ok: boolean }>;
-  };
   files: {
     list: (path: string, showHidden?: boolean) => Promise<FilesListResult>;
     read: (path: string) => Promise<FilesReadResult>;
@@ -1033,17 +1058,49 @@ export interface SessionManagerAPI {
     stop: (tabId: string) => Promise<{ ok: boolean }>;
     onStateChanged: (handler: (ev: SuperAgentStateChangedEvent) => void) => () => void;
   };
+  webRemote: {
+    getStatus: () => Promise<WebRemoteStatus>;
+    enable: () => Promise<WebRemoteMutationResult>;
+    disable: () => Promise<WebRemoteMutationResult>;
+    pair: (otp: string) => Promise<WebRemotePairResult>;
+    revokeDevice: (deviceId: string) => Promise<WebRemoteMutationResult>;
+    auditTail: (lines?: number) => Promise<WebRemoteAuditTailResult>;
+    onStatus: (handler: (status: WebRemoteStatus) => void) => () => void;
+    onTokenRevoked: (handler: (ev: { deviceId: string }) => void) => () => void;
+    /** Revoke ALL paired devices and tear down every session immediately (panic). */
+    revokeAll: () => Promise<WebRemoteMutationResult>;
+    /** Subscribe to the completion event broadcast after revokeAll. */
+    onRevokedAll: (handler: (ev: { revokedCount: number }) => void) => () => void;
+  };
   kg: {
-    /** Distilled knowledge graph + ingest status over the prompt log. */
-    get: () => Promise<KgState>;
-    /** Process new prompt-log lines into the graph (incremental). */
-    ingest: () => Promise<{ ok: boolean; added?: number; nodes?: number; edges?: number; error?: string; note?: string }>;
-    /** Ask a question answered from the graph + your real prompts via claude -p. */
-    ask: (question: string) => Promise<{ ok: boolean; answer?: string; cited?: { ts: string; prompt: string }[]; error?: string }>;
+    /** Distilled knowledge graph + ingest status for ONE project (`cwd`).
+     *  Omit `cwd` for the most-active project. */
+    get: (cwd?: string) => Promise<KgState>;
+    /** Projects seen in the prompt log, with per-project graph stats. */
+    projects: () => Promise<KgProject[]>;
+    /** Process new prompt-log lines into per-project graphs (incremental, global). */
+    ingest: () => Promise<{ ok: boolean; added?: number; projects?: number; stopped?: boolean; error?: string; note?: string }>;
+    /** Ask a question answered from ONE project's graph + prompts via claude -p. */
+    ask: (question: string, cwd?: string) => Promise<{ ok: boolean; answer?: string; cited?: { ts: string; prompt: string }[]; error?: string }>;
     onIngestProgress: (handler: (ev: KgIngestProgress) => void) => () => void;
   };
 }
 
+export interface KgProject {
+  cwd: string;
+  /** Last path segment of `cwd`, for display. */
+  label: string;
+  /** Prompts logged for this project (real prompts only). */
+  total: number;
+  /** Prompts already distilled into this project's graph. */
+  processed: number;
+  /** total - processed. */
+  pending: number;
+  nodes: number;
+  edges: number;
+  lastIngest: string | null;
+}
+
 export interface KgNode {
   id: string;
   key: string;
@@ -1062,6 +1119,10 @@ export interface KgEdge {
   lastTs: string | null;
 }
 export interface KgState {
+  /** The project this graph belongs to. */
+  cwd: string;
+  /** Last path segment of `cwd`, for display. */
+  label: string;
   nodes: KgNode[];
   edges: KgEdge[];
   status: {
@@ -1074,11 +1135,13 @@ export interface KgState {
   };
 }
 export interface KgIngestProgress {
-  phase: 'start' | 'extract' | 'done' | 'error';
+  phase: 'start' | 'extract' | 'batch' | 'done' | 'error';
   ingesting: boolean;
   batch?: number;
   totalBatches?: number;
   added?: number;
+  /** Set on `batch`: the project cwd whose graph just committed. */
+  cwd?: string;
   error?: string;
 }
 

package/src/preload/index.cjs

@@ -156,11 +156,6 @@ contextBridge.exposeInMainWorld('api', {
     aggregate: (req) => ipcRenderer.invoke('history:aggregate', req),
     listConversations: () => ipcRenderer.invoke('history:list-conversations'),
   },
-  projectSkills: {
-    get: (cwd) => ipcRenderer.invoke('project-skills:get', { cwd }),
-    set: (cwd, skillId, enabled) =>
-      ipcRenderer.invoke('project-skills:set', { cwd, skillId, enabled }),
-  },
   files: {
     list: (path, showHidden) => ipcRenderer.invoke('files:list', { path, showHidden }),
     read: (path) => ipcRenderer.invoke('files:read', { path }),
@@ -281,11 +276,49 @@ contextBridge.exposeInMainWorld('api', {
       return () => ipcRenderer.removeListener('superagent:state-changed', listener);
     },
   },
+  webRemote: {
+    /** Current connection state (no token values). */
+    getStatus: () => ipcRenderer.invoke('webRemote:get-status'),
+    /** Turn remote control on. Initiates relay connection if a device is paired. */
+    enable: () => ipcRenderer.invoke('webRemote:enable'),
+    /** Turn remote control off. Immediately drops relay connection. */
+    disable: () => ipcRenderer.invoke('webRemote:disable'),
+    /** Pair a new device using the 8-character OTP shown in the web UI. */
+    pair: (otp) => ipcRenderer.invoke('webRemote:pair', { otp }),
+    /** Revoke a paired device by its deviceId. */
+    revokeDevice: (deviceId) => ipcRenderer.invoke('webRemote:revoke-device', { deviceId }),
+    /** Read the last N lines of today's audit log (default 50). */
+    auditTail: (lines) => ipcRenderer.invoke('webRemote:audit-tail', lines ? { lines } : {}),
+    /** Push event from main when connection status changes. */
+    onStatus: (handler) => {
+      const listener = (_e, payload) => handler(payload);
+      ipcRenderer.on('webRemote:status', listener);
+      return () => ipcRenderer.removeListener('webRemote:status', listener);
+    },
+    /** Push event when the relay revokes this device's token. */
+    onTokenRevoked: (handler) => {
+      const listener = (_e, payload) => handler(payload);
+      ipcRenderer.on('webRemote:token-revoked', listener);
+      return () => ipcRenderer.removeListener('webRemote:token-revoked', listener);
+    },
+    /** Revoke ALL paired devices and tear down every session immediately. */
+    revokeAll: () => ipcRenderer.invoke('webRemote:revoke-all'),
+    /** Push event when revokeAll completes (main broadcasts webRemote:revoked-all). */
+    onRevokedAll: (handler) => {
+      const listener = (_e, payload) => handler(payload);
+      ipcRenderer.on('webRemote:revoked-all', listener);
+      return () => ipcRenderer.removeListener('webRemote:revoked-all', listener);
+    },
+  },
   kg: {
-    /** Knowledge Graph distilled from the prompt log (~/.claude/knowledge-log). */
-    get: () => ipcRenderer.invoke('kg:get'),
+    /** Knowledge Graph distilled from the prompt log (~/.claude/knowledge-log),
+     *  segregated per project. `cwd` selects which project's graph; omit for the
+     *  most-active project. */
+    get: (cwd) => ipcRenderer.invoke('kg:get', { cwd }),
+    /** Projects seen in the log, with per-project graph stats (for the selector). */
+    projects: () => ipcRenderer.invoke('kg:projects'),
     ingest: () => ipcRenderer.invoke('kg:ingest'),
-    ask: (question) => ipcRenderer.invoke('kg:ask', { question }),
+    ask: (question, cwd) => ipcRenderer.invoke('kg:ask', { question, cwd }),
     onIngestProgress: (handler) => {
       const listener = (_e, payload) => handler(payload);
       ipcRenderer.on('kg:ingest-progress', listener);

package/src/main/projectSkills.cjs

@@ -1,124 +0,0 @@
-/**
- * ProjectSkills — per-project skill enable/disable state.
- *
- * Storage: <cwd>/.claude/project-skills.json
- *   Format: { skills: Array<{ skillId: string; enabled: boolean }>, schemaVersion: 1 }
- *
- * Reads enumerate all skills under <cwd>/.claude/skills/ and <home>/.claude/skills/
- * and merge their enable state from the project-local config. Skills not listed in
- * the JSON default to `enabled: true` (i.e., opt-out per project).
- *
- * IPC:
- *   - project-skills:get(cwd) -> SkillState[]
- *   - project-skills:set(cwd, skillId, enabled) -> { ok: boolean }
- *
- * Atomic writes go through config.cjs::writeJson. cwd is validated via
- * validatePath which constrains it to allowedRoots (home + registered project
- * dirs).
- */
-
-const { ipcMain } = require('electron');
-const path = require('node:path');
-const { z } = require('zod');
-const { readJson, writeJson, addAllowedRoot } = require('./config.cjs');
-
-const SCHEMA_VERSION = 1;
-
-function projectSkillsPath(cwd) {
-  return path.join(cwd, '.claude', 'project-skills.json');
-}
-
-/**
- * Load the project-skills.json record for a cwd. Missing file => empty record.
- * Returns { skills: Array<{skillId, enabled}>, schemaVersion }.
- */
-async function loadRecord(cwd) {
-  const filePath = projectSkillsPath(cwd);
-  const r = await readJson(filePath);
-  if (!r.exists || !r.data || typeof r.data !== 'object') {
-    return { skills: [], schemaVersion: SCHEMA_VERSION };
-  }
-  const data = r.data;
-  const skills = Array.isArray(data.skills) ? data.skills : [];
-  // Filter for well-formed entries; tolerate corruption silently.
-  const clean = [];
-  const seen = new Set();
-  for (const s of skills) {
-    if (!s || typeof s.skillId !== 'string' || typeof s.enabled !== 'boolean') continue;
-    if (seen.has(s.skillId)) continue;
-    seen.add(s.skillId);
-    clean.push({ skillId: s.skillId, enabled: s.enabled });
-  }
-  return { skills: clean, schemaVersion: SCHEMA_VERSION };
-}
-
-async function saveRecord(cwd, record) {
-  const filePath = projectSkillsPath(cwd);
-  const payload = {
-    schemaVersion: SCHEMA_VERSION,
-    skills: record.skills,
-    savedAt: Date.now(),
-  };
-  return writeJson(filePath, payload);
-}
-
-/** Return the array of skill enable-states for a project cwd. */
-async function getProjectSkills(cwd) {
-  // Register cwd so writeJson is permitted under <cwd>/.claude.
-  addAllowedRoot(cwd);
-  const record = await loadRecord(cwd);
-  return record.skills;
-}
-
-/** Upsert a single skillId's enabled flag. */
-async function setProjectSkill(cwd, skillId, enabled) {
-  addAllowedRoot(cwd);
-  const record = await loadRecord(cwd);
-  const idx = record.skills.findIndex((s) => s.skillId === skillId);
-  if (idx >= 0) {
-    record.skills[idx] = { skillId, enabled };
-  } else {
-    record.skills.push({ skillId, enabled });
-  }
-  await saveRecord(cwd, record);
-  return { ok: true };
-}
-
-// ──────────────────────────────────────────── IPC schemas
-const projectSkillsCwd = z.object({
-  cwd: z.string().min(1).max(4096),
-});
-
-const projectSkillsSet = z.object({
-  cwd: z.string().min(1).max(4096),
-  skillId: z.string().min(1).max(256),
-  enabled: z.boolean(),
-});
-
-function validated(schema, handler) {
-  return (_event, payload) => {
-    const parsed = schema.parse(payload);
-    return handler(parsed);
-  };
-}
-
-function registerProjectSkillsHandlers() {
-  ipcMain.handle(
-    'project-skills:get',
-    validated(projectSkillsCwd, ({ cwd }) => getProjectSkills(cwd)),
-  );
-  ipcMain.handle(
-    'project-skills:set',
-    validated(projectSkillsSet, ({ cwd, skillId, enabled }) =>
-      setProjectSkill(cwd, skillId, enabled),
-    ),
-  );
-}
-
-module.exports = {
-  registerProjectSkillsHandlers,
-  // Exported for tests / direct use.
-  getProjectSkills,
-  setProjectSkill,
-  projectSkillsPath,
-};