clearclaw 0.6.1 → 0.8.0

package/dist/config.js

@@ -28,19 +28,25 @@ export function resolveDataDir() {
 export class Config {
     // Resolved settings — populated by resolve()
     channel;
+    engines;
+    defaultEngine; // derived: name of the engine with default: true
     permissionMode = "default";
     envUserIds = new Set();
     // Derived paths
-    defaultPromptPath;
+    homeWorkspacePath;
     filesPath;
     logPath;
+    instructionsDir;
+    frameworkPromptDir;
     dataDir = resolveDataDir();
     filePath;
     constructor() {
         this.filePath = path.join(this.dataDir, "config.json");
-        this.defaultPromptPath = path.join(this.dataDir, "workspace", "CLAUDE.md");
+        this.homeWorkspacePath = path.join(this.dataDir, "workspace");
         this.filesPath = path.join(this.dataDir, "files");
         this.logPath = path.join(this.dataDir, "clearclaw.log");
+        this.instructionsDir = path.join(this.dataDir, "workspace", "instructions");
+        this.frameworkPromptDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "prompts");
     }
     /** Resolve channel + env vars. Throws if no channel config found. */
     resolve() {
@@ -70,26 +76,42 @@ export class Config {
             throw new Error(`PERMISSION_MODE must be one of: ${valid.join(", ")}`);
         }
         this.permissionMode = pm;
+        const data = this.read();
+        if (!data.engines?.length) {
+            throw new Error("No engines configured. Run `clearclaw setup`.");
+        }
+        this.engines = Object.fromEntries(data.engines.map((e) => [e.name, e]));
+        const defaultEntry = data.engines.find((e) => e.default);
+        if (!defaultEntry) {
+            throw new Error("No default engine configured. Run `clearclaw setup`.");
+        }
+        this.defaultEngine = defaultEntry.name;
         return this;
     }
     // --- File I/O (internal) ---
-    read() {
-        if (!fs.existsSync(this.filePath)) {
-            return { authorizedUsers: [], pendingPairings: [], workspaces: [] };
-        }
+    readRaw() {
+        if (!fs.existsSync(this.filePath))
+            return {};
         try {
-            const raw = JSON.parse(fs.readFileSync(this.filePath, "utf-8"));
-            return {
-                channel: raw.channel,
-                authorizedUsers: raw.authorizedUsers ?? [],
-                pendingPairings: raw.pendingPairings ?? [],
-                workspaces: raw.workspaces ?? [],
-            };
+            return JSON.parse(fs.readFileSync(this.filePath, "utf-8"));
         }
         catch {
-            return { authorizedUsers: [], pendingPairings: [], workspaces: [] };
+            return {};
         }
     }
+    read() {
+        const raw = this.readRaw();
+        return {
+            ...raw,
+            channel: raw.channel,
+            engines: raw.engines,
+            authorizedUsers: (raw.authorizedUsers ?? []),
+            pendingPairings: (raw.pendingPairings ?? []),
+            workspaces: (raw.workspaces ?? []),
+            schedules: (raw.schedules ?? []),
+            projects: (raw.projects ?? []),
+        };
+    }
     write(data) {
         fs.writeFileSync(this.filePath, JSON.stringify(data, null, 2) + "\n", { mode: 0o600 });
     }
@@ -102,6 +124,12 @@ export class Config {
         data.channel = config;
         this.write(data);
     }
+    // --- Engines ---
+    setEngines(engines) {
+        const data = this.read();
+        data.engines = engines;
+        this.write(data);
+    }
     // --- Authorized users ---
     hasUser(userId) {
         return this.read().authorizedUsers.some((u) => u.id === userId);
@@ -116,6 +144,13 @@ export class Config {
     listUsers() {
         return this.read().authorizedUsers;
     }
+    /** All authorized IDs, including environment-configured and pairing-approved users. */
+    listAuthorizedUserIds() {
+        return [...new Set([
+                ...this.envUserIds,
+                ...this.listUsers().map((user) => user.id),
+            ])];
+    }
     /** env var IDs (in-memory) + pairing-approved users (hot-reload from disk) */
     isAuthorized(userId) {
         return this.envUserIds.has(userId) || this.hasUser(userId);
@@ -159,12 +194,59 @@ export class Config {
             .join("");
     }
     // --- Workspaces ---
+    /** Home exists before a chat is paired. Never replace an existing home's settings. */
+    ensureHomeWorkspace() {
+        fs.mkdirSync(this.homeWorkspacePath, { recursive: true });
+        const data = this.read();
+        let home = data.workspaces.find((ws) => ws.name === "default");
+        let changed = false;
+        if (!home) {
+            home = { name: "default", cwd: this.homeWorkspacePath, chat_id: null,
+                current_session_id: null, behavior: "assistant", description: "Personal assistant", project: "home" };
+            // Avoid adopting an unrelated project with a reserved home name.
+            if (data.projects.some((project) => project.name === "home" && project.main_workspace !== "default")) {
+                throw new Error('Project "home" already has another main workspace; rename it before creating home.');
+            }
+            data.workspaces.push(home);
+            changed = true;
+        }
+        if (!home.project) {
+            const existing = data.projects.find((project) => project.main_workspace === home.name);
+            home.project = existing?.name ?? "home";
+            if (data.projects.some((project) => project.name === home.project && project.main_workspace !== home.name)) {
+                throw new Error(`Project "${home.project}" already has another main workspace.`);
+            }
+            changed = true;
+        }
+        if (!data.projects.some((project) => project.name === home.project)) {
+            data.projects.push({ name: home.project, description: home.description ?? "Personal assistant", main_workspace: home.name });
+            changed = true;
+        }
+        if (changed)
+            this.write(data);
+        return home;
+    }
+    /**
+     * ensureHomeWorkspace creates home's records at startup, before any chat is known.
+     * This gives it its destination, once: an existing binding is never replaced.
+     * Callers decide what counts as home's chat — see Channel.isRootDM.
+     */
+    connectHomeWorkspace(chatId) {
+        const home = this.ensureHomeWorkspace();
+        if (home.chat_id || this.workspaceByChat(chatId))
+            return false;
+        this.upsertWorkspace({ ...home, chat_id: chatId });
+        return true;
+    }
     workspaceByChat(chatId) {
         return this.read().workspaces.find((ws) => ws.chat_id === chatId);
     }
     workspaceByName(name) {
         return this.read().workspaces.find((ws) => ws.name === name);
     }
+    listWorkspaces() {
+        return this.read().workspaces;
+    }
     upsertWorkspace(ws) {
         const data = this.read();
         const idx = data.workspaces.findIndex((w) => w.name === ws.name);
@@ -174,6 +256,16 @@ export class Config {
             data.workspaces.push(ws);
         this.write(data);
     }
+    removeWorkspace(name) {
+        const data = this.read();
+        const idx = data.workspaces.findIndex((w) => w.name === name);
+        if (idx < 0)
+            return undefined;
+        const [removed] = data.workspaces.splice(idx, 1);
+        this.write(data);
+        return removed;
+    }
+    /** Persist the session ID without changing the saved model setting. */
     setSession(name, sessionId) {
         const data = this.read();
         const ws = data.workspaces.find((w) => w.name === name);
@@ -187,6 +279,15 @@ export class Config {
         const ws = data.workspaces.find((w) => w.name === name);
         if (ws) {
             ws.current_session_id = null;
+            delete ws.engine_handoff;
+            this.write(data);
+        }
+    }
+    setModel(name, model) {
+        const data = this.read();
+        const ws = data.workspaces.find((w) => w.name === name);
+        if (ws) {
+            ws.model = model;
             this.write(data);
         }
     }
@@ -198,27 +299,52 @@ export class Config {
             this.write(data);
         }
     }
-    // --- Approval ---
-    ensureDefaultWorkspace(chatId) {
-        if (this.workspaceByChat(chatId) || this.workspaceByName("default"))
-            return;
-        const defaultCwd = path.join(this.dataDir, "workspace");
-        fs.mkdirSync(defaultCwd, { recursive: true });
-        this.upsertWorkspace({ name: "default", cwd: defaultCwd, chat_id: chatId, current_session_id: null });
-        this.syncSkills();
-    }
-    /** Copy bundled skills from the repo's skills/ directory to the home workspace's .claude/skills/. */
-    syncSkills() {
-        const pkgRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-        const srcSkills = path.join(pkgRoot, "skills");
-        if (!fs.existsSync(srcSkills))
-            return;
-        const destSkills = path.join(this.dataDir, "workspace", ".claude", "skills");
-        fs.cpSync(srcSkills, destSkills, { recursive: true, force: true });
+    // --- Projects ---
+    addProject(project) {
+        const data = this.read();
+        const idx = data.projects.findIndex((p) => p.name === project.name);
+        if (idx >= 0)
+            data.projects[idx] = project;
+        else
+            data.projects.push(project);
+        this.write(data);
+    }
+    listProjects() {
+        return this.read().projects;
     }
-    approveUser(userId, userName, chatId) {
+    projectByName(name) {
+        return this.read().projects.find((p) => p.name === name);
+    }
+    removeProject(name) {
+        const data = this.read();
+        data.projects = data.projects.filter((p) => p.name !== name);
+        this.write(data);
+    }
+    // --- Schedules ---
+    listSchedules() {
+        return this.read().schedules;
+    }
+    addSchedule(entry) {
+        const data = this.read();
+        data.schedules.push(entry);
+        this.write(data);
+    }
+    removeSchedule(id) {
+        const data = this.read();
+        data.schedules = data.schedules.filter((s) => s.id !== id);
+        this.write(data);
+    }
+    updateSchedule(id, update) {
+        const data = this.read();
+        const entry = data.schedules.find((s) => s.id === id);
+        if (entry) {
+            Object.assign(entry, update);
+            this.write(data);
+        }
+    }
+    // --- Approval ---
+    approveUser(userId, userName) {
         this.addUser({ id: userId, name: userName, approvedAt: Date.now() });
-        this.ensureDefaultWorkspace(chatId);
     }
 }
 //# sourceMappingURL=config.js.map

package/dist/engine/acp.d.ts

@@ -0,0 +1,14 @@
+import type { AcpEngineDefinition } from "./registry.js";
+import type { Engine, EngineEvent, PlanUsageWindow, RunTurnOpts, SessionInfo, SessionHistoryOpts, SessionMessage } from "../types.js";
+export declare class AcpEngine implements Engine {
+    readonly name: string;
+    private readonly spawnConfig;
+    constructor(name: string, spawnConfig: AcpEngineDefinition);
+    runTurn(opts: RunTurnOpts): AsyncIterable<EngineEvent>;
+    getSessionMessages(opts: SessionHistoryOpts): Promise<SessionMessage[]>;
+    listSessions(cwd: string): Promise<SessionInfo[]>;
+    /** Short-lived, read-only ACP queries share one deadline and always release the child. */
+    private readSessionData;
+}
+/** PR #334's provider extension. Never treat standard ACP used/size as plan usage. */
+export declare function codexPlanUsage(meta: unknown): PlanUsageWindow[];