@cjhyy/code-shell-core 0.8.8 → 0.8.10

package/dist/automation/scheduler.js

@@ -38,6 +38,50 @@ const MAX_SCHEDULE_INTERVAL_MS = 10 * 365 * 24 * 60 * 60 * 1000;
 export function isCronMisfire(scheduledFor, now) {
     return now - scheduledFor > CRON_MISFIRE_GRACE_MS;
 }
+const MAX_JOB_NAME_CHARS = 512;
+const MAX_JOB_SCHEDULE_CHARS = 512;
+const MAX_JOB_PROMPT_CHARS = 1024 * 1024;
+const MAX_JOB_CWD_CHARS = 32_768;
+const MAX_JOB_TIMEZONE_CHARS = 128;
+function validateJobFields(input) {
+    if (input.name !== undefined &&
+        (typeof input.name !== "string" ||
+            !input.name.trim() ||
+            input.name.length > MAX_JOB_NAME_CHARS ||
+            input.name.includes("\0"))) {
+        throw new Error("automation name must be a bounded non-empty string");
+    }
+    if (input.schedule !== undefined &&
+        (typeof input.schedule !== "string" ||
+            !input.schedule.trim() ||
+            input.schedule.length > MAX_JOB_SCHEDULE_CHARS ||
+            input.schedule.includes("\0"))) {
+        throw new Error("automation schedule must be a bounded non-empty string");
+    }
+    if (input.prompt !== undefined &&
+        (typeof input.prompt !== "string" ||
+            !input.prompt.trim() ||
+            input.prompt.length > MAX_JOB_PROMPT_CHARS ||
+            input.prompt.includes("\0"))) {
+        throw new Error("automation prompt must be a bounded non-empty string");
+    }
+    if (input.cwd !== undefined &&
+        (typeof input.cwd !== "string" || input.cwd.length > MAX_JOB_CWD_CHARS || input.cwd.includes("\0"))) {
+        throw new Error("automation cwd must be a bounded string");
+    }
+    if (input.timezone !== undefined &&
+        (typeof input.timezone !== "string" ||
+            input.timezone.length > MAX_JOB_TIMEZONE_CHARS ||
+            input.timezone.includes("\0"))) {
+        throw new Error("automation timezone must be a bounded string");
+    }
+    if (input.permissionLevel !== undefined &&
+        input.permissionLevel !== "read-only" &&
+        input.permissionLevel !== "workspace-write" &&
+        input.permissionLevel !== "full") {
+        throw new Error("invalid automation permission level");
+    }
+}
 export class CronScheduler {
     jobs = new Map();
     timers = new Map();
@@ -301,6 +345,7 @@ export class CronScheduler {
         }
     }
     create(name, schedule, prompt, opts) {
+        validateJobFields({ name, schedule, prompt, ...opts });
         // Validate the schedule up front (interval or cron expr) so a bad string
         // surfaces at create time, not silently at the first missed tick.
         validateSchedule(schedule, opts?.timezone);
@@ -459,6 +504,10 @@ export class CronScheduler {
      * or null if the id is unknown.
      */
     update(id, patch) {
+        if (!patch || typeof patch !== "object" || Array.isArray(patch)) {
+            throw new Error("automation update patch must be an object");
+        }
+        validateJobFields(patch);
         if (this.store) {
             const tx = this.store.mutate((jobs) => {
                 let updated = null;

package/dist/automation/store.d.ts

@@ -11,7 +11,7 @@
  * the same lock and one process cannot overwrite another process's new job
  * with a stale in-memory snapshot.
  */
-import type { CronJob } from "./scheduler.js";
+import { type CronJob } from "./scheduler.js";
 /**
  * Default global location. Mirrors FileRunStore's `~/.code-shell/...` layout.
  * An explicit `root` (a `~/.code-shell`-equivalent data root) overrides the

package/dist/automation/store.js

@@ -11,11 +11,145 @@
  * the same lock and one process cannot overwrite another process's new job
  * with a stale in-memory snapshot.
  */
-import { mkdirSync, existsSync, readFileSync, writeFileSync, renameSync, rmSync } from "node:fs";
+import { chmodSync, mkdirSync, existsSync, readFileSync, statSync, writeFileSync, renameSync, rmSync, } from "node:fs";
+import { randomUUID } from "node:crypto";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
+import { validateSchedule } from "./scheduler.js";
 import { logger } from "../logging/logger.js";
 import { lockSync } from "../utils/lockfile.js";
+const MAX_CRON_FILE_BYTES = 32 * 1024 * 1024;
+const MAX_CRON_JOBS = 4_096;
+const SAFE_ID = /^[A-Za-z0-9_.-]{1,128}$/;
+function normalizeJob(value, strict) {
+    const invalid = (field) => {
+        if (strict)
+            throw new Error(`invalid cron job ${field}`);
+        return undefined;
+    };
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return invalid("object");
+    const raw = value;
+    if (typeof raw.id !== "string" || !SAFE_ID.test(raw.id) || raw.id.includes("..")) {
+        return invalid("id");
+    }
+    if (typeof raw.name !== "string" ||
+        !raw.name.trim() ||
+        raw.name.length > 512 ||
+        raw.name.includes("\0")) {
+        return invalid("name");
+    }
+    if (typeof raw.schedule !== "string" ||
+        !raw.schedule.trim() ||
+        raw.schedule.length > 512 ||
+        raw.schedule.includes("\0")) {
+        return invalid("schedule");
+    }
+    if (typeof raw.prompt !== "string" ||
+        !raw.prompt.trim() ||
+        raw.prompt.length > 1024 * 1024 ||
+        raw.prompt.includes("\0")) {
+        return invalid("prompt");
+    }
+    if (typeof raw.enabled !== "boolean")
+        return invalid("enabled");
+    if (!Number.isSafeInteger(raw.runCount) || raw.runCount < 0) {
+        return invalid("runCount");
+    }
+    if (!Number.isSafeInteger(raw.createdAt) || raw.createdAt < 0) {
+        return invalid("createdAt");
+    }
+    if (raw.cwd !== undefined &&
+        (typeof raw.cwd !== "string" || raw.cwd.length > 32_768 || raw.cwd.includes("\0"))) {
+        return invalid("cwd");
+    }
+    if (raw.timezone !== undefined &&
+        (typeof raw.timezone !== "string" || raw.timezone.length > 128 || raw.timezone.includes("\0"))) {
+        return invalid("timezone");
+    }
+    if (raw.permissionLevel !== undefined &&
+        raw.permissionLevel !== "read-only" &&
+        raw.permissionLevel !== "workspace-write" &&
+        raw.permissionLevel !== "full") {
+        return invalid("permissionLevel");
+    }
+    for (const field of ["lastRun", "nextRun"]) {
+        if (raw[field] !== undefined &&
+            (!Number.isSafeInteger(raw[field]) || raw[field] < 0)) {
+            return invalid(field);
+        }
+    }
+    for (const field of ["lastRunId", "resumeSessionId"]) {
+        if (raw[field] !== undefined &&
+            (typeof raw[field] !== "string" ||
+                !raw[field] ||
+                raw[field].length > 128 ||
+                raw[field].includes("\0"))) {
+            return invalid(field);
+        }
+    }
+    if (raw.once !== undefined && typeof raw.once !== "boolean")
+        return invalid("once");
+    if (raw.disabledReason !== undefined &&
+        (typeof raw.disabledReason !== "string" || raw.disabledReason.length > 4_096)) {
+        return invalid("disabledReason");
+    }
+    let templateSource;
+    if (raw.templateSource !== undefined) {
+        if (!raw.templateSource || typeof raw.templateSource !== "object" || Array.isArray(raw.templateSource)) {
+            return invalid("templateSource");
+        }
+        const source = raw.templateSource;
+        if (typeof source.installKey !== "string" ||
+            !source.installKey ||
+            source.installKey.length > 512 ||
+            typeof source.templateId !== "string" ||
+            !source.templateId ||
+            source.templateId.length > 512 ||
+            typeof source.revision !== "string" ||
+            !source.revision ||
+            source.revision.length > 512 ||
+            (source.pluginVersion !== undefined &&
+                (typeof source.pluginVersion !== "string" || source.pluginVersion.length > 128))) {
+            return invalid("templateSource");
+        }
+        templateSource = {
+            installKey: source.installKey,
+            templateId: source.templateId,
+            revision: source.revision,
+            ...(typeof source.pluginVersion === "string" ? { pluginVersion: source.pluginVersion } : {}),
+        };
+    }
+    try {
+        validateSchedule(raw.schedule, typeof raw.timezone === "string" ? raw.timezone : undefined);
+    }
+    catch {
+        return invalid("schedule");
+    }
+    return {
+        id: raw.id,
+        name: raw.name,
+        schedule: raw.schedule,
+        prompt: raw.prompt,
+        enabled: raw.enabled,
+        runCount: raw.runCount,
+        createdAt: raw.createdAt,
+        ...(typeof raw.lastRun === "number" ? { lastRun: raw.lastRun } : {}),
+        ...(typeof raw.nextRun === "number" ? { nextRun: raw.nextRun } : {}),
+        ...(typeof raw.cwd === "string" ? { cwd: raw.cwd } : {}),
+        ...(typeof raw.timezone === "string" ? { timezone: raw.timezone } : {}),
+        ...(raw.permissionLevel === "read-only" ||
+            raw.permissionLevel === "workspace-write" ||
+            raw.permissionLevel === "full"
+            ? { permissionLevel: raw.permissionLevel }
+            : {}),
+        ...(typeof raw.lastRunId === "string" ? { lastRunId: raw.lastRunId } : {}),
+        ...(raw.once === true ? { once: true } : {}),
+        ...(typeof raw.resumeSessionId === "string" ? { resumeSessionId: raw.resumeSessionId } : {}),
+        ...(typeof raw.disabledReason === "string" ? { disabledReason: raw.disabledReason } : {}),
+        ...(templateSource ? { templateSource } : {}),
+    };
+}
 /**
  * Default global location. Mirrors FileRunStore's `~/.code-shell/...` layout.
  * An explicit `root` (a `~/.code-shell`-equivalent data root) overrides the
@@ -64,11 +198,23 @@ export class CronStore {
         if (!existsSync(this.file))
             return [];
         try {
+            if (statSync(this.file).size > MAX_CRON_FILE_BYTES) {
+                throw new Error("cron store exceeds the maximum file size");
+            }
             const raw = readFileSync(this.file, "utf-8");
             const parsed = JSON.parse(raw);
             if (!parsed || !Array.isArray(parsed.jobs))
                 return [];
-            return parsed.jobs;
+            const jobs = [];
+            const ids = new Set();
+            for (const value of parsed.jobs.slice(0, MAX_CRON_JOBS)) {
+                const job = normalizeJob(value, false);
+                if (!job || ids.has(job.id))
+                    continue;
+                ids.add(job.id);
+                jobs.push(job);
+            }
+            return jobs;
         }
         catch (err) {
             // Corrupt snapshot — log and start fresh rather than crashing startup.
@@ -81,25 +227,53 @@ export class CronStore {
         }
     }
     saveUnlocked(jobs) {
+        if (!Array.isArray(jobs) || jobs.length > MAX_CRON_JOBS) {
+            throw new Error("cron store exceeds the maximum job count");
+        }
+        const normalized = [];
+        const ids = new Set();
+        let estimatedBytes = 32;
+        for (const value of jobs) {
+            const job = normalizeJob(value, true);
+            if (ids.has(job.id))
+                throw new Error(`duplicate cron job id: ${job.id}`);
+            ids.add(job.id);
+            estimatedBytes += Buffer.byteLength(JSON.stringify(job)) + 2;
+            if (estimatedBytes > MAX_CRON_FILE_BYTES) {
+                throw new Error("cron store exceeds the maximum file size");
+            }
+            normalized.push(job);
+        }
         const dir = dirname(this.file);
         if (!existsSync(dir))
-            mkdirSync(dir, { recursive: true });
-        const snapshot = { version: 1, jobs };
+            mkdirSync(dir, { recursive: true, mode: 0o700 });
+        if (process.platform !== "win32")
+            chmodSync(dir, 0o700);
+        const snapshot = { version: 1, jobs: normalized };
         // Unique tmp name so a concurrent writer can't clobber our staging file.
-        const tmp = `${this.file}.${process.pid}.tmp`;
+        const tmp = `${this.file}.${process.pid}.${randomUUID()}.tmp`;
         try {
-            writeFileSync(tmp, JSON.stringify(snapshot, null, 2) + "\n", "utf-8");
+            writeFileSync(tmp, JSON.stringify(snapshot, null, 2) + "\n", {
+                encoding: "utf-8",
+                mode: 0o600,
+            });
             renameSync(tmp, this.file);
         }
-        catch (err) {
-            rmSync(tmp, { force: true });
-            throw err;
+        finally {
+            try {
+                rmSync(tmp, { force: true });
+            }
+            catch {
+                // Preserve the original persistence error.
+            }
         }
     }
     acquireStoreLock() {
         const dir = dirname(this.file);
         if (!existsSync(dir))
-            mkdirSync(dir, { recursive: true });
+            mkdirSync(dir, { recursive: true, mode: 0o700 });
+        if (process.platform !== "win32")
+            chmodSync(dir, 0o700);
         const deadline = Date.now() + 1_000;
         let lastError;
         while (Date.now() <= deadline) {

package/dist/cli/agent-server-stdio.js

@@ -40,6 +40,7 @@ import { StdioTransport } from "../protocol/transport.js";
 import { createNotification, Methods } from "../protocol/types.js";
 import { setCronChangedSink } from "../tool-system/builtin/cron.js";
 import { setModelCatalogChangedSink } from "../tool-system/builtin/edit-model-catalog.js";
+import { setCapabilityChangedSink } from "../tool-system/builtin/install-capability.js";
 import { SettingsManager, noRepoDir } from "../settings/manager.js";
 import { personalizationFrom } from "../settings/personalization.js";
 import { MCPManager } from "../tool-system/mcp-manager.js";
@@ -338,6 +339,12 @@ setCronChangedSink(() => {
 setModelCatalogChangedSink(() => {
     stdioTransport.send(createNotification(Methods.SettingsChanged, {}));
 });
+// Conversational Plugin/Skill/MCP installs happen inside this worker. Tell the
+// mounted Desktop renderer to refresh catalogs and push a fresh settings patch
+// back to all live sessions, matching installs initiated from Extensions.
+setCapabilityChangedSink(() => {
+    stdioTransport.send(createNotification(Methods.SettingsChanged, {}));
+});
 // Disk-only active-goal reader for agent/goalGet. In worker mode there is no
 // legacyEngine, and reopening a session after restart doesn't create a live
 // ChatSession (that only happens on a send), so chatManager.get() misses. This

package/dist/credentials/store.d.ts

@@ -47,7 +47,21 @@ export declare class CredentialStore {
      */
     private decryptSecret;
     private read;
+    /**
+     * Read the store, reporting whether the on-disk state was fully understood.
+     *
+     * `readable: false` means "there is a file here but this build could not
+     * parse it" — NOT "there are no credentials". The distinction matters because
+     * mutate() commits whatever this returns: treating an unreadable file as an
+     * empty list turns any later save() into a wipe of every stored credential.
+     *
+     * `unknown` carries entries this build's schema rejects (for example a
+     * credential type added by a newer version). They are kept verbatim so a
+     * round-trip through an older build preserves rather than deletes them.
+     */
+    private readGuarded;
     private write;
+    private mutate;
     /** Upsert by id within a scope. */
     save(scope: CredentialScope, cred: Credential): void;
     /**