@sema-agent/server 1.308.0 → 1.309.0

package/dist/capabilities/center-plugins.d.ts

@@ -0,0 +1,63 @@
+import type { Logger } from "../observability/logger.js";
+import { type LoadedSkill } from "./skills.js";
+export declare const DEFAULT_PLUGIN_ALLOW_HOSTS: readonly string[];
+export interface PluginDeclWire {
+    name?: unknown;
+    source?: {
+        kind?: unknown;
+        url?: unknown;
+        marketplace?: unknown;
+    };
+    version?: unknown;
+    sha?: unknown;
+    enabled?: unknown;
+}
+export type PluginValidation = {
+    ok: true;
+    name: string;
+    url: string;
+    sha?: string;
+} | {
+    ok: false;
+    skip?: true;
+    name: string;
+    reason: string;
+};
+export declare function validatePluginDecl(decl: PluginDeclWire, allowHosts: readonly string[]): PluginValidation;
+export declare function gitClonePlan(o: {
+    url: string;
+    dest: string;
+    sha?: string;
+}): {
+    steps: string[][];
+    env: Record<string, string>;
+};
+export declare function resolvePluginSkillsRoot(cloneRoot: string): {
+    ok: true;
+    dir?: string;
+} | {
+    ok: false;
+    reason: string;
+};
+export interface ApplyPluginsResult {
+    skills: LoadedSkill[];
+    failures: Array<{
+        plugin: string;
+        reason: string;
+    }>;
+    letGo: Array<{
+        plugin: string;
+        skill: string;
+    }>;
+    lkgUsed: string[];
+}
+export declare function applyCenterPlugins(baseline: LoadedSkill[], eff: {
+    plugins?: unknown;
+}, opts: {
+    cacheRoot: string;
+    allowHosts: readonly string[];
+    logger?: Logger;
+    skipValidate?: boolean;
+    runGit?: (args: string[], env: Record<string, string>) => Promise<void>;
+}): Promise<ApplyPluginsResult>;
+//# sourceMappingURL=center-plugins.d.ts.map

package/dist/capabilities/center-plugins.js

@@ -0,0 +1,163 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { promises as fsp, realpathSync, existsSync, readFileSync } from "node:fs";
+import { join, resolve, isAbsolute, sep } from "node:path";
+import { loadSkills } from "./skills.js";
+const execFileP = promisify(execFile);
+export const DEFAULT_PLUGIN_ALLOW_HOSTS = ["github.com"];
+export function validatePluginDecl(decl, allowHosts) {
+    const name = typeof decl.name === "string" && decl.name !== "" ? decl.name : "(unnamed)";
+    if (decl.enabled === false)
+        return { ok: false, skip: true, name, reason: "enabled:false" };
+    const kind = decl.source?.kind;
+    if (kind === "marketplace") {
+        return { ok: false, skip: true, name, reason: "marketplace source: not materialized in v1 (skills lane ships git-form first)" };
+    }
+    if (kind !== "git")
+        return { ok: false, name, reason: `unsupported source.kind ${String(kind)}` };
+    const url = decl.source?.url;
+    if (typeof url !== "string" || !/^https:\/\//i.test(url)) {
+        return { ok: false, name, reason: `plugin source must be an https:// URL (contract: https-only; got ${String(url).slice(0, 80)})` };
+    }
+    let host;
+    try {
+        host = new URL(url).hostname.toLowerCase();
+    }
+    catch {
+        return { ok: false, name, reason: "https url does not parse" };
+    }
+    if (!allowHosts.some((h) => h.toLowerCase() === host)) {
+        return { ok: false, name, reason: `host ${host} not in PLUGINS_ALLOW_HOSTS (default github.com; extend with a comma-separated https mirror domain list)` };
+    }
+    if (decl.sha !== undefined) {
+        if (typeof decl.sha !== "string" || !/^[a-f0-9]{40}$/.test(decl.sha)) {
+            return { ok: false, name, reason: `sha must be a full 40-hex lowercase commit (got ${String(decl.sha).slice(0, 50)})` };
+        }
+        return { ok: true, name, url, sha: decl.sha };
+    }
+    return { ok: true, name, url };
+}
+export function gitClonePlan(o) {
+    const env = {
+        GIT_CONFIG_GLOBAL: "/dev/null",
+        GIT_CONFIG_SYSTEM: "/dev/null",
+        GIT_TERMINAL_PROMPT: "0",
+    };
+    if (o.sha === undefined) {
+        return { steps: [["clone", "--depth", "1", "--quiet", o.url, o.dest]], env };
+    }
+    return {
+        steps: [
+            ["init", "--quiet", o.dest],
+            ["-C", o.dest, "fetch", "--depth", "1", "--quiet", o.url, o.sha],
+            ["-C", o.dest, "checkout", "--quiet", o.sha],
+        ],
+        env,
+    };
+}
+export function resolvePluginSkillsRoot(cloneRoot) {
+    let skillsPath = "skills";
+    try {
+        const manifest = JSON.parse(readFileSync(join(cloneRoot, ".claude-plugin", "plugin.json"), "utf8"));
+        if (typeof manifest.skillsPath === "string" && manifest.skillsPath !== "")
+            skillsPath = manifest.skillsPath;
+    }
+    catch {
+    }
+    if (isAbsolute(skillsPath))
+        return { ok: false, reason: `skillsPath must be relative (got ${skillsPath})` };
+    const rootReal = realpathSync(cloneRoot);
+    const candidate = resolve(rootReal, skillsPath);
+    if (candidate !== rootReal && !candidate.startsWith(rootReal + sep)) {
+        return { ok: false, reason: `skillsPath escapes the plugin root (${skillsPath})` };
+    }
+    if (!existsSync(candidate))
+        return { ok: true };
+    const real = realpathSync(candidate);
+    if (real !== rootReal && !real.startsWith(rootReal + sep)) {
+        return { ok: false, reason: `skillsPath resolves outside the plugin root via symlink (${skillsPath})` };
+    }
+    return { ok: true, dir: candidate };
+}
+export async function applyCenterPlugins(baseline, eff, opts) {
+    const declared = Array.isArray(eff.plugins)
+        ? (eff.plugins)
+        : Array.isArray(eff.plugins?.plugins)
+            ? (eff.plugins.plugins)
+            : [];
+    const out = { skills: [...baseline], failures: [], letGo: [], lkgUsed: [] };
+    if (declared.length === 0)
+        return out;
+    const runGit = opts.runGit ?? (async (args, env) => {
+        await execFileP("git", args, { env: { ...process.env, ...env }, timeout: 120_000, maxBuffer: 4 * 1024 * 1024 });
+    });
+    const taken = new Set(baseline.map((s) => s.spec.name));
+    for (const decl of declared) {
+        const v = opts.skipValidate
+            ? { ok: true, name: String(decl.name), url: String(decl.source?.url), ...(typeof decl.sha === "string" ? { sha: decl.sha } : {}) }
+            : validatePluginDecl(decl, opts.allowHosts);
+        if (!v.ok) {
+            if (v.skip)
+                opts.logger?.info("center_plugin_skipped", { plugin: v.name, reason: v.reason });
+            else {
+                opts.logger?.warn("center_plugin_rejected", { plugin: v.name, reason: v.reason });
+                out.failures.push({ plugin: v.name, reason: v.reason });
+            }
+            continue;
+        }
+        const liveDir = join(opts.cacheRoot, v.name, "live");
+        const staging = join(opts.cacheRoot, v.name, `staging-${process.pid}`);
+        let materialized = false;
+        try {
+            await fsp.rm(staging, { recursive: true, force: true });
+            await fsp.mkdir(staging, { recursive: true });
+            const plan = gitClonePlan({ url: v.url, dest: staging, sha: v.sha });
+            for (const step of plan.steps)
+                await runGit(step, plan.env);
+            await fsp.rm(liveDir, { recursive: true, force: true });
+            await fsp.mkdir(join(opts.cacheRoot, v.name), { recursive: true });
+            await fsp.rename(staging, liveDir);
+            materialized = true;
+        }
+        catch (err) {
+            await fsp.rm(staging, { recursive: true, force: true }).catch(() => undefined);
+            if (existsSync(liveDir)) {
+                opts.logger?.warn("center_plugin_fetch_failed_lkg", { plugin: v.name, error: err instanceof Error ? err.message : String(err) });
+                out.lkgUsed.push(v.name);
+            }
+            else {
+                opts.logger?.warn("center_plugin_fetch_failed", { plugin: v.name, error: err instanceof Error ? err.message : String(err) });
+                out.failures.push({ plugin: v.name, reason: `fetch failed: ${err instanceof Error ? err.message : String(err)}` });
+                continue;
+            }
+        }
+        try {
+            const rootCheck = resolvePluginSkillsRoot(liveDir);
+            if (!rootCheck.ok) {
+                out.failures.push({ plugin: v.name, reason: rootCheck.reason });
+                opts.logger?.warn("center_plugin_manifest_rejected", { plugin: v.name, reason: rootCheck.reason });
+                continue;
+            }
+            if (!rootCheck.dir)
+                continue;
+            const loaded = loadSkills(rootCheck.dir);
+            for (const skill of loaded) {
+                if (taken.has(skill.spec.name)) {
+                    out.letGo.push({ plugin: v.name, skill: skill.spec.name });
+                    opts.logger?.warn("center_plugin_skill_shadowed", { plugin: v.name, skill: skill.spec.name, note: "name taken by builtin/center skill — plugin yields (contract tightening-4)" });
+                    continue;
+                }
+                taken.add(skill.spec.name);
+                out.skills.push(skill);
+            }
+            if (materialized)
+                opts.logger?.info("center_plugin_loaded", { plugin: v.name, skills: loaded.length, pinned: v.sha !== undefined });
+        }
+        catch (err) {
+            out.failures.push({ plugin: v.name, reason: `load failed: ${err instanceof Error ? err.message : String(err)}` });
+            opts.logger?.warn("center_plugin_load_failed", { plugin: v.name, error: err instanceof Error ? err.message : String(err) });
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=center-plugins.js.map

package/dist/config.d.ts

@@ -164,6 +164,7 @@ export interface ServiceConfig {
     };
     snapshotBlobSqlMaxBytes?: number;
     snapshotBlobAllowSql: boolean;
+    pluginsAllowHosts: string[];
     bindHost?: string;
     attachmentOrphanGraceMs: number;
     workspaceFileMaxBytes: number;

package/dist/config.js

@@ -538,6 +538,7 @@ export function loadConfig() {
             : undefined,
         snapshotBlobSqlMaxBytes: optFinitePositiveEnv("SNAPSHOT_BLOB_SQL_MAX_BYTES"),
         snapshotBlobAllowSql: process.env.SNAPSHOT_BLOB_ALLOW_SQL_BYTES === "true",
+        pluginsAllowHosts: (process.env.PLUGINS_ALLOW_HOSTS ?? "github.com").split(",").map((h) => h.trim()).filter(Boolean),
         bindHost: process.env.BIND_HOST || process.env.HOST || undefined,
         attachmentOrphanGraceMs: ((v) => (v !== undefined && Number.isFinite(v) && v >= 0 ? v : 3_600_000))(process.env.ATTACHMENT_ORPHAN_GRACE_MS !== undefined ? Number(process.env.ATTACHMENT_ORPHAN_GRACE_MS) : undefined),
         workspaceFileMaxBytes: optFinitePositiveEnv("WORKSPACE_FILE_MAX_BYTES") ?? 8 * 1024 * 1024,

package/dist/http/server.js

@@ -634,7 +634,7 @@ export function createHttpServer(deps) {
         }
         if (deps.drainState?.draining && req.method === "POST" && isBillableSubmitPath(url)) {
             res.setHeader("retry-after", "15");
-            sendJson(res, 503, { error: "draining", message: "this instance is draining for shutdown/upgrade — retry against the replacement instance" });
+            sendJson(res, 503, { error: "draining", errorCode: "draining", message: "this instance is draining for shutdown/upgrade — retry against the replacement instance" });
             return;
         }
         if (deps.modelReady && !deps.modelReady() && req.method === "POST" && isBillableSubmitPath(url)) {

package/dist/main.js

@@ -46,6 +46,7 @@ import { buildSessionAuditPg, buildSessionAuditLocal, buildSessionAudit } from "
 import { makeDegenerateInstrument } from "./degenerate-instrument.js";
 import { PlanCacheProbe } from "./plan-cache-probe.js";
 import { loadSkills } from "./capabilities/skills.js";
+import { applyCenterPlugins } from "./capabilities/center-plugins.js";
 import { GiteaClient } from "./capabilities/repo-tools.js";
 import { buildScenarios, selectScenario, centerScenarios, mergeUserSkills, builtinScenarioDetails, centerScenarioDetails, gateScenarioRequest } from "./capabilities/scenarios.js";
 import { applyLongtailDefer } from "./capabilities/tool-defer.js";
@@ -1270,6 +1271,22 @@ async function main() {
     if (effective?.skills && config.configCenter) {
         skills = await applyCenterSkills(skills, effective.skills, config.configCenter.baseUrl, config.configCenter.token, logger, undefined, process.env.CONFIG_LKG_DISABLED !== "true" ? defaultSkillCacheDir() : undefined);
     }
+    if (effective?.plugins && config.configCenter) {
+        const pluginOut = await applyCenterPlugins(skills, effective, {
+            cacheRoot: join(config.localDataRoot ?? join(homedir(), ".ai-agent"), "plugin-cache"),
+            allowHosts: config.pluginsAllowHosts,
+            logger,
+        }).catch((err) => {
+            logger.warn("center_plugins_apply_failed", { error: err instanceof Error ? err.message : String(err) });
+            return undefined;
+        });
+        if (pluginOut) {
+            skills = pluginOut.skills;
+            if (pluginOut.failures.length + pluginOut.letGo.length + pluginOut.lkgUsed.length > 0) {
+                logger.info("center_plugins_applied", { failures: pluginOut.failures, letGo: pluginOut.letGo, lkgUsed: pluginOut.lkgUsed });
+            }
+        }
+    }
     if (bootLkgCandidate && lkgEnabled) {
         const bootPublished = await persistLkgDurable(bootLkgCandidate.effective, bootLkgCandidate.etag).catch((err) => {
             logger.warn("config_lkg_save_failed", { path: lkgPath, err: String(err), note: "boot LKG persist failed — retained for the per-tick retry" });

package/dist/orchestration/workflow-completion-inbox.js

@@ -174,7 +174,7 @@ export class FileWorkflowCompletionInbox extends InMemoryWorkflowCompletionInbox
             closeSync(this.fd);
             this.fd = undefined;
         }
-        const tmp = `${this.ledgerPath}.tmp`;
+        const tmp = `${this.ledgerPath}.tmp.${process.pid}`;
         const lines = [];
         for (const q of this.bySession.values())
             for (const entry of q.values())

package/dist/sema-registry.d.ts

@@ -133,6 +133,9 @@ export interface EffectiveConfig {
         commandPolicy?: CommandRule[];
         approvalRequire?: string[];
     };
+    plugins?: {
+        plugins?: unknown[];
+    };
     prompts?: unknown;
 }
 export interface ExecutionRuling {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/server",
-  "version": "1.308.0",
+  "version": "1.309.0",
   "description": "Sema Server — the server/API implementation layer for Sema, wiring core, registry, model providers, and cloud agent execution. Built on @sema-agent/core.",
   "type": "module",
   "license": "BUSL-1.1",
@@ -10,7 +10,11 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
-    }
+    },
+    "./main": {
+      "default": "./dist/main.js"
+    },
+    "./package.json": "./package.json"
   },
   "files": [
     "dist",