jishushell 0.6.5 → 0.6.18

package/dist/services/runtime/mcp-shims/jishukb-shim.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"jishukb-shim.js","sourceRoot":"","sources":["../../../../src/services/runtime/mcp-shims/jishukb-shim.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,MAAM,CAAC,MAAM,wBAAwB,GAAG,OAAO,CAAC;AAEhD;8EAC8E;AAC9E,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC;AAEtC,oCAAoC;AACpC,MAAM,CAAC,MAAM,wBAAwB,GAAG,MAAM,CAAC;AAE/C,wCAAwC;AACxC,MAAM,CAAC,MAAM,wBAAwB,GAAG,EAAE,GAAG,IAAI,GAAG,IAAI,CAAC;AAEzD,MAAM,CAAC,MAAM,uBAAuB,GAAG;;;;;;;;;;;;;;;;;;uBAkBhB,oBAAoB;wBACnB,wBAAwB;2BACrB,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uDAokBI,IAAI,CAAC,SAAS,CAAC,wBAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwE9F,CAAC;AAEF;;;;;GAKG;AACH,MAAM,UAAU,iCAAiC,CAC/C,MAAwE;IAExE,MAAM,SAAS,GAAG,CAAC,CAAS,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAC/E,OAAO,uBAAuB;SAC3B,OAAO,CAAC,kBAAkB,EAAE,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;SACtD,OAAO,CAAC,eAAe,EAAE,SAAS,CAAC,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC;SACtD,OAAO,CAAC,8BAA8B,EAAE,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;AACnG,CAAC"}

package/dist/services/runtime/mcp-shims/mcporter-lite.js

@@ -1,276 +0,0 @@
-/**
- * Lightweight mcporter-compatible wrapper used by OpenClaw instances.
- *
- * Why this exists:
- *   - The agent-facing TOOLS.md has long instructed models to shell out to
- *     `mcporter call ...`, but fresh / host-mode instances often do not carry
- *     an actual mcporter npm install under `$OPENCLAW_HOME/.npm-global/`.
- *   - We only need a tiny subset for built-in JishuShell shims:
- *       1. `mcporter list --json`
- *       2. `mcporter call <server>.<tool> key=value ...`
- *   - A self-contained wrapper avoids depending on PATH, npm postinstalls,
- *     or a third-party binary living in the right place.
- *
- * Scope:
- *   - Reads `mcporter.json`
- *   - Supports stdio-backed MCP servers
- *   - Speaks NDJSON JSON-RPC 2.0 (same framing as our in-tree shims)
- *
- * Non-goals:
- *   - Full mcporter CLI parity
- *   - HTTP/SSE transports
- *   - Interactive TUI flows
- */
-export function renderStandaloneMcporterSource() {
-    return `#!/usr/bin/env node
-// jishushell-mcporter-lite — generated, do not edit by hand.
-// Source: src/services/runtime/mcp-shims/mcporter-lite.ts
-import { spawn } from "node:child_process";
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { createInterface } from "node:readline";
-
-const DEFAULT_TIMEOUT_MS = 30000;
-
-function fail(msg, code = 1) {
-  process.stderr.write(msg + "\\n");
-  process.exit(code);
-}
-
-function shellUsage() {
-  fail(
-    "usage: mcporter [--config PATH] list [--json]\\n" +
-    "       mcporter [--config PATH] call <server>.<tool> key=value ...",
-    2,
-  );
-}
-
-function parseCli(argv) {
-  let configPath = process.env.MCPORTER_CONFIG || "";
-  const rest = [];
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i];
-    if (arg === "--config") {
-      i++;
-      if (i >= argv.length) shellUsage();
-      configPath = argv[i];
-      continue;
-    }
-    if (arg.startsWith("--config=")) {
-      configPath = arg.slice("--config=".length);
-      continue;
-    }
-    rest.push(arg);
-  }
-  if (!configPath) {
-    configPath = resolve(process.cwd(), "config", "mcporter.json");
-  }
-  return { configPath, rest };
-}
-
-function loadConfig(path) {
-  let raw;
-  try {
-    raw = JSON.parse(readFileSync(path, "utf-8"));
-  } catch (e) {
-    fail("mcporter: cannot read config " + path + ": " + (e && e.message ? e.message : e), 2);
-  }
-  if (!raw || typeof raw !== "object") {
-    fail("mcporter: config must be a JSON object", 2);
-  }
-  if (!raw.mcpServers || typeof raw.mcpServers !== "object") {
-    raw.mcpServers = {};
-  }
-  return raw;
-}
-
-function coerceValue(raw) {
-  if (raw === "true") return true;
-  if (raw === "false") return false;
-  if (raw === "null") return null;
-  if (/^-?\\d+(?:\\.\\d+)?$/.test(raw)) return Number(raw);
-  if ((raw.startsWith("{") && raw.endsWith("}")) || (raw.startsWith("[") && raw.endsWith("]"))) {
-    try { return JSON.parse(raw); } catch { /* keep string */ }
-  }
-  return raw;
-}
-
-function parseKeyValueArgs(argv) {
-  const out = {};
-  for (const token of argv) {
-    const eq = token.indexOf("=");
-    if (eq < 0) {
-      fail("mcporter: expected key=value argument, got: " + token, 2);
-    }
-    const key = token.slice(0, eq).trim();
-    const raw = token.slice(eq + 1);
-    if (!key) fail("mcporter: empty argument key", 2);
-    out[key] = coerceValue(raw);
-  }
-  return out;
-}
-
-function printableResult(result) {
-  const content = result && result.content;
-  if (Array.isArray(content)) {
-    const textBlocks = content
-      .filter((item) => item && item.type === "text")
-      .map((item) => typeof item.text === "string" ? item.text : "");
-    if (textBlocks.length > 0) return textBlocks.join("\\n\\n");
-  }
-  return JSON.stringify(result, null, 2);
-}
-
-async function callStdioServer(entry, toolName, toolArgs) {
-  if (!entry || typeof entry !== "object" || !entry.command) {
-    fail("mcporter: server entry is missing command", 2);
-  }
-  const command = entry.command === "node" ? process.execPath : String(entry.command);
-  const args = Array.isArray(entry.args) ? entry.args.map((v) => String(v)) : [];
-  const env = { ...process.env };
-  if (entry.env && typeof entry.env === "object") {
-    for (const [k, v] of Object.entries(entry.env)) {
-      if (v != null) env[k] = String(v);
-    }
-  }
-
-  const child = spawn(command, args, {
-    env,
-    stdio: ["pipe", "pipe", "pipe"],
-  });
-
-  let stderr = "";
-  child.stderr.on("data", (chunk) => {
-    stderr += chunk.toString("utf-8");
-  });
-
-  const rl = createInterface({ input: child.stdout });
-  const pending = new Map();
-  let nextId = 1;
-
-  const cleanup = () => {
-    try { child.stdin.end(); } catch {}
-    rl.close();
-    if (!child.killed) child.kill();
-  };
-
-  const request = (method, params, expectReply = true) => new Promise((resolveReq, rejectReq) => {
-    const id = expectReply ? nextId++ : undefined;
-    let timer = null;
-    if (expectReply) {
-      timer = setTimeout(() => {
-        pending.delete(id);
-        rejectReq(new Error("timeout waiting for " + method));
-      }, DEFAULT_TIMEOUT_MS);
-      pending.set(id, (msg) => {
-        clearTimeout(timer);
-        if (msg && msg.error) rejectReq(new Error(msg.error.message || JSON.stringify(msg.error)));
-        else resolveReq(msg ? msg.result : undefined);
-      });
-    }
-    const payload = { jsonrpc: "2.0", method };
-    if (id !== undefined) payload.id = id;
-    if (params !== undefined) payload.params = params;
-    child.stdin.write(JSON.stringify(payload) + "\\n");
-    if (!expectReply) resolveReq(undefined);
-  });
-
-  rl.on("line", (line) => {
-    let msg;
-    try { msg = JSON.parse(line); } catch { return; }
-    if (msg && msg.id !== undefined && pending.has(msg.id)) {
-      const done = pending.get(msg.id);
-      pending.delete(msg.id);
-      done(msg);
-    }
-  });
-
-  child.on("error", (err) => {
-    for (const [, done] of pending) done({ error: { message: err.message } });
-    pending.clear();
-  });
-
-  child.on("exit", (code, signal) => {
-    if (pending.size === 0) return;
-    const detail = stderr.trim() || ("upstream exited code=" + code + " signal=" + signal);
-    for (const [, done] of pending) done({ error: { message: detail } });
-    pending.clear();
-  });
-
-  try {
-    await request("initialize", {
-      protocolVersion: "2024-11-05",
-      capabilities: {},
-      clientInfo: { name: "jishushell-mcporter-lite", version: "0.1.0" },
-    });
-    await request("notifications/initialized", undefined, false);
-    const result = await request("tools/call", {
-      name: toolName,
-      arguments: toolArgs,
-    });
-    cleanup();
-    return result;
-  } catch (e) {
-    cleanup();
-    throw e;
-  }
-}
-
-async function main() {
-  const { configPath, rest } = parseCli(process.argv.slice(2));
-  if (rest.length === 0) shellUsage();
-  const cfg = loadConfig(configPath);
-  const cmd = rest[0];
-
-  if (cmd === "list") {
-    const asJson = rest.includes("--json");
-    const servers = Object.entries(cfg.mcpServers || {}).map(([name, entry]) => ({
-      name,
-      transport: entry && typeof entry === "object"
-        ? (entry.transport || (entry.command ? "stdio" : entry.url ? "http" : "unknown"))
-        : "unknown",
-      command: entry && typeof entry === "object" && entry.command ? String(entry.command) : undefined,
-      args: entry && typeof entry === "object" && Array.isArray(entry.args)
-        ? entry.args.map((v) => String(v))
-        : undefined,
-      url: entry && typeof entry === "object" && entry.url ? String(entry.url) : undefined,
-    }));
-    if (asJson) {
-      process.stdout.write(JSON.stringify({ servers }) + "\\n");
-      return;
-    }
-    for (const server of servers) {
-      process.stdout.write(server.name + "\\t" + server.transport + "\\n");
-    }
-    return;
-  }
-
-  if (cmd === "call") {
-    if (rest.length < 2) shellUsage();
-    const target = rest[1];
-    const dot = target.indexOf(".");
-    if (dot <= 0 || dot === target.length - 1) {
-      fail("mcporter: expected <server>.<tool>, got: " + target, 2);
-    }
-    const serverName = target.slice(0, dot);
-    const toolName = target.slice(dot + 1);
-    const entry = cfg.mcpServers[serverName];
-    if (!entry) fail("mcporter: unknown server '" + serverName + "'", 2);
-    if (entry.url && !entry.command) {
-      fail("mcporter: only stdio-backed servers are supported by this wrapper", 2);
-    }
-    const toolArgs = parseKeyValueArgs(rest.slice(2));
-    const result = await callStdioServer(entry, toolName, toolArgs);
-    process.stdout.write(printableResult(result) + "\\n");
-    return;
-  }
-
-  shellUsage();
-}
-
-main().catch((e) => {
-  fail("mcporter: " + (e && e.message ? e.message : e));
-});
-`;
-}
-//# sourceMappingURL=mcporter-lite.js.map

package/dist/services/runtime/mcp-shims/mcporter-lite.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"mcporter-lite.js","sourceRoot":"","sources":["../../../../src/services/runtime/mcp-shims/mcporter-lite.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,MAAM,UAAU,8BAA8B;IAC5C,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyPR,CAAC;AACF,CAAC"}

package/dist/services/runtime/migrations.d.ts

@@ -1,23 +0,0 @@
-/**
- * Instance metadata migration layer (plan §30.1).
- *
- * `resolveAgentType()` defaults to `"openclaw"` when `instance.json` has
- * no `agentType` field (dev-branch instances created before the
- * multi-runtime contract). `backfillInstanceMeta()` normalises the
- * in-memory meta so callers always see an explicit `agentType`.
- *
- * Per plan §30.1, the backfill is NOT persisted on read — that would
- * trigger a mass rewrite on every panel boot. The next `updateInstance()`
- * / `updateInstanceMeta()` saves the normalised shape naturally.
- *
- * This file is framework-level and must never import adapter code.
- */
-import type { AppSpec } from "../../types.js";
-export declare function backfillInstanceMeta<T extends Record<string, any>>(raw: T | null | undefined): T | null;
-/**
- * Return a synthetic capability-only spec for a legacy instance based on
- * its agentType. Returns null when the agent type has no known template
- * (e.g. raw `custom` agents). Cached per-agentType — templates ship with
- * the panel and don't change at runtime.
- */
-export declare function loadCapabilitySpecForLegacyInstance(meta: Record<string, any> | null): AppSpec | null;

package/dist/services/runtime/migrations.js

@@ -1,125 +0,0 @@
-/**
- * Instance metadata migration layer (plan §30.1).
- *
- * `resolveAgentType()` defaults to `"openclaw"` when `instance.json` has
- * no `agentType` field (dev-branch instances created before the
- * multi-runtime contract). `backfillInstanceMeta()` normalises the
- * in-memory meta so callers always see an explicit `agentType`.
- *
- * Per plan §30.1, the backfill is NOT persisted on read — that would
- * trigger a mass rewrite on every panel boot. The next `updateInstance()`
- * / `updateInstanceMeta()` saves the normalised shape naturally.
- *
- * This file is framework-level and must never import adapter code.
- */
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
-import { fileURLToPath } from "url";
-import { parse } from "yaml";
-import { resolveAgentType } from "./instance.js";
-export function backfillInstanceMeta(raw) {
-    if (!raw)
-        return null;
-    const agentType = resolveAgentType(raw);
-    const mut = raw;
-    if (mut.agentType !== agentType)
-        mut.agentType = agentType;
-    return raw;
-}
-// ── Capability discovery for legacy instances ──────────────────────────────
-//
-// PR 1+2 introduced the capability registry / app-spec contract. Legacy
-// hermes/openclaw instances created via the old "新建实例" flow only carry
-// `instance.json` — they have no `app-spec.yaml`, no `manifest.json`, and
-// no `app_id`. The Connections endpoint then early-returns
-// `{requires:[], connections:{}, pending:[]}` and the UI shows "此应用没
-// 有需要绑定的能力。" even though every hermes/openclaw runtime *should*
-// expose the standard llm/search/browser/mcp slots.
-//
-// We deliberately do NOT write any files for these instances:
-//
-//   - The shipped templates (`apps/openclaw-container.yaml`,
-//     `apps/hermes-container.yaml`) describe a *container* runtime
-//     (image / args / ports). Legacy instances may run as raw_exec on a
-//     local binary instead, with their real runtime in
-//     `instance.json#runtime`. Persisting the container spec would
-//     cause `nomad-manager.startAppJob(spec, ...)` to rebuild the job
-//     from the wrong runtime shape on next start, losing volume mounts
-//     and per-instance customisation.
-//
-//   - The Connections feature only needs `spec.requires` (and a stable
-//     `spec.id`) to populate the UI. We can synthesize that in-memory
-//     from the matching template every time the Connections route is
-//     hit. There is no state to drift, nothing to migrate, nothing to
-//     undo.
-//
-// The synthetic spec returned by `loadCapabilitySpecForLegacyInstance`
-// is therefore pruned to capability metadata only. Service routes
-// (start / stop / restart) keep going through the legacy
-// `svc.startInstance` path because `meta.app_id` stays unset — the
-// runtime continues to come from `instance.json`.
-const TEMPLATE_BY_AGENT_TYPE = {
-    hermes: "hermes-container.yaml",
-    openclaw: "openclaw-container.yaml",
-};
-function resolveTemplatePath(templateName) {
-    const candidates = [
-        fileURLToPath(new URL(`../../../apps/${templateName}`, import.meta.url)),
-        join(process.cwd(), "apps", templateName),
-    ];
-    for (const candidate of candidates) {
-        if (existsSync(candidate))
-            return candidate;
-    }
-    return null;
-}
-const specCache = new Map();
-/**
- * Return a synthetic capability-only spec for a legacy instance based on
- * its agentType. Returns null when the agent type has no known template
- * (e.g. raw `custom` agents). Cached per-agentType — templates ship with
- * the panel and don't change at runtime.
- */
-export function loadCapabilitySpecForLegacyInstance(meta) {
-    if (!meta)
-        return null;
-    const agentType = typeof meta.agentType === "string" && meta.agentType
-        ? meta.agentType
-        : resolveAgentType(meta);
-    const templateName = TEMPLATE_BY_AGENT_TYPE[agentType];
-    if (!templateName)
-        return null;
-    if (specCache.has(agentType)) {
-        return specCache.get(agentType) ?? null;
-    }
-    const templatePath = resolveTemplatePath(templateName);
-    if (!templatePath) {
-        specCache.set(agentType, null);
-        return null;
-    }
-    try {
-        const raw = parse(readFileSync(templatePath, "utf-8"));
-        // Strip runtime — Connections only needs id/name/requires/provides.
-        // Leaving `tasks` in would tempt callers to (re)build a nomad job
-        // from a spec that doesn't match the instance's actual runtime.
-        const synthetic = {
-            id: raw.id,
-            name: raw.name,
-            version: raw.version,
-            agentType: raw.agentType,
-            description: raw.description,
-            singleInstance: raw.singleInstance,
-            tasks: [],
-            provides: raw.provides ?? [],
-            requires: raw.requires ?? [],
-        };
-        specCache.set(agentType, synthetic);
-        return synthetic;
-    }
-    catch (e) {
-        console.warn(`[migration] cannot load capability template '${templateName}': ${e.message}`);
-        specCache.set(agentType, null);
-        return null;
-    }
-}
-//# sourceMappingURL=migrations.js.map

package/dist/services/runtime/migrations.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"migrations.js","sourceRoot":"","sources":["../../../src/services/runtime/migrations.ts"],"names":[],"mappings":"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"}

package/dist/services/runtime/registry.d.ts

@@ -1,13 +0,0 @@
-/**
- * Runtime adapter registry — resolves agentType → adapter instance.
- *
- * `agentType` is the single canonical discriminator across TypeScript code,
- * on-disk `instance.json`, and HTTP APIs.
- */
-import type { AgentType, RuntimeAdapter } from "./types.js";
-export declare function registerAdapter(adapter: RuntimeAdapter): void;
-export declare function getAdapter(agentType: AgentType): RuntimeAdapter;
-export declare function hasAdapter(agentType: AgentType): boolean;
-export declare function listRegisteredAdapters(): RuntimeAdapter[];
-/** Test-only / reset helper. Never call from production code paths. */
-export declare function __resetRegistryForTests(): void;

package/dist/services/runtime/registry.js

@@ -1,32 +0,0 @@
-/**
- * Runtime adapter registry — resolves agentType → adapter instance.
- *
- * `agentType` is the single canonical discriminator across TypeScript code,
- * on-disk `instance.json`, and HTTP APIs.
- */
-const registry = new Map();
-export function registerAdapter(adapter) {
-    if (registry.has(adapter.agentType)) {
-        throw new Error(`Runtime adapter for agentType "${adapter.agentType}" already registered`);
-    }
-    registry.set(adapter.agentType, adapter);
-}
-export function getAdapter(agentType) {
-    const adapter = registry.get(agentType);
-    if (!adapter) {
-        throw new Error(`No runtime adapter registered for agentType="${agentType}". ` +
-            `Registered types: [${[...registry.keys()].join(", ") || "none"}]`);
-    }
-    return adapter;
-}
-export function hasAdapter(agentType) {
-    return registry.has(agentType);
-}
-export function listRegisteredAdapters() {
-    return [...registry.values()];
-}
-/** Test-only / reset helper. Never call from production code paths. */
-export function __resetRegistryForTests() {
-    registry.clear();
-}
-//# sourceMappingURL=registry.js.map

package/dist/services/runtime/registry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../../src/services/runtime/registry.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,MAAM,QAAQ,GAAG,IAAI,GAAG,EAA6B,CAAC;AAEtD,MAAM,UAAU,eAAe,CAAC,OAAuB;IACrD,IAAI,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC;QACpC,MAAM,IAAI,KAAK,CAAC,kCAAkC,OAAO,CAAC,SAAS,sBAAsB,CAAC,CAAC;IAC7F,CAAC;IACD,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;AAC3C,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,SAAoB;IAC7C,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IACxC,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CACb,gDAAgD,SAAS,KAAK;YAC5D,sBAAsB,CAAC,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,MAAM,GAAG,CACrE,CAAC;IACJ,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,SAAoB;IAC7C,OAAO,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;AACjC,CAAC;AAED,MAAM,UAAU,sBAAsB;IACpC,OAAO,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;AAChC,CAAC;AAED,uEAAuE;AACvE,MAAM,UAAU,uBAAuB;IACrC,QAAQ,CAAC,KAAK,EAAE,CAAC;AACnB,CAAC"}

package/dist/services/runtime-identity.d.ts

@@ -1,13 +0,0 @@
-import type { AppSpec } from "../types.js";
-export type RuntimeDriver = "runtime-adapter" | "app-job" | "local-model";
-export type RuntimeInstallMode = "app-dir" | "instance-dir" | "legacy";
-export interface RuntimeIdentity {
-    id: string;
-    installMode: RuntimeInstallMode;
-    driver: RuntimeDriver;
-    agentType?: string;
-    appSpec?: AppSpec;
-    instanceMeta?: Record<string, any>;
-}
-export declare function resolveRuntimeIdentity(id: string): RuntimeIdentity | null;
-export declare function invalidateRuntimeIdentity(id?: string): void;

package/dist/services/runtime-identity.js

@@ -1,166 +0,0 @@
-import { existsSync, readFileSync, statSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-import { parse } from "yaml";
-import * as config from "../config.js";
-import { hasAdapter } from "./runtime/index.js";
-const CACHE_TTL_MS = 5_000;
-const cache = new Map();
-function configValue(name) {
-    return name in config ? config[name] : undefined;
-}
-function configPath(name, fallback) {
-    const value = configValue(name);
-    return typeof value === "string" && value.trim() ? value : fallback;
-}
-function appsDir() {
-    const home = configPath("JISHUSHELL_HOME", join(process.env.HOME ?? homedir(), ".jishushell"));
-    return configPath("APPS_DIR", join(home, "apps"));
-}
-function instancesDir() {
-    const home = configPath("JISHUSHELL_HOME", join(process.env.HOME ?? homedir(), ".jishushell"));
-    return configPath("INSTANCES_DIR", join(home, "instances"));
-}
-function candidateLocations(id) {
-    return [
-        { dir: join(appsDir(), id), installMode: "app-dir" },
-        { dir: join(instancesDir(), id), installMode: "instance-dir" },
-    ];
-}
-function fileFingerprint(path) {
-    try {
-        const st = statSync(path);
-        return `${path}:1:${st.mtimeMs}:${st.size}`;
-    }
-    catch {
-        return `${path}:0`;
-    }
-}
-function computeFingerprint(id) {
-    const parts = [];
-    for (const location of candidateLocations(id)) {
-        parts.push(`${location.installMode}:${location.dir}:${existsSync(location.dir) ? 1 : 0}`);
-        parts.push(fileFingerprint(join(location.dir, "instance.json")));
-        parts.push(fileFingerprint(join(location.dir, "manifest.json")));
-        parts.push(fileFingerprint(join(location.dir, "app-spec.yaml")));
-    }
-    return parts.join("|");
-}
-function readJson(path) {
-    if (!existsSync(path))
-        return null;
-    try {
-        return JSON.parse(readFileSync(path, "utf-8"));
-    }
-    catch {
-        return null;
-    }
-}
-function readYaml(path) {
-    if (!existsSync(path))
-        return null;
-    try {
-        return parse(readFileSync(path, "utf-8"));
-    }
-    catch {
-        return null;
-    }
-}
-function normalizeAgentType(value) {
-    return typeof value === "string" && value.trim() ? value.trim() : "";
-}
-function registeredAgentType(value) {
-    const agentType = normalizeAgentType(value);
-    if (!agentType)
-        return null;
-    return hasAdapter(agentType) ? agentType : null;
-}
-function appSpecAgentType(spec) {
-    if (!spec)
-        return null;
-    return registeredAgentType(spec.agentType)
-        ?? registeredAgentType(spec._engine?.agentType);
-}
-function isOllamaIdentity(id, appSpec, instanceMeta) {
-    const appType = typeof instanceMeta?.app_type === "string" ? instanceMeta.app_type.trim() : "";
-    if (appType === "ollama")
-        return true;
-    const specId = typeof appSpec?.id === "string" ? appSpec.id : "";
-    const text = specId || id;
-    return /^ollama(?:[-_]|$)/i.test(text);
-}
-function firstExistingLocation(id) {
-    for (const location of candidateLocations(id)) {
-        if (existsSync(location.dir))
-            return location;
-    }
-    return null;
-}
-function resolveFresh(id) {
-    const locations = candidateLocations(id);
-    const records = locations.map((location) => ({
-        ...location,
-        instanceMeta: readJson(join(location.dir, "instance.json")),
-        manifest: readJson(join(location.dir, "manifest.json")),
-        appSpec: readYaml(join(location.dir, "app-spec.yaml")),
-    }));
-    const instanceRecord = records.find((record) => record.instanceMeta);
-    const appRecord = records.find((record) => record.appSpec && record.manifest);
-    const anyRecord = instanceRecord ?? appRecord ?? records.find((record) => record.appSpec || record.manifest) ?? firstExistingLocation(id);
-    if (!anyRecord)
-        return null;
-    const instanceMeta = instanceRecord?.instanceMeta ?? null;
-    const appSpec = appRecord?.appSpec ?? records.find((record) => record.appSpec)?.appSpec ?? null;
-    const installMode = appRecord?.manifest?.install_mode
-        ?? appRecord?.installMode
-        ?? instanceRecord?.installMode
-        ?? "legacy";
-    const metaAgentType = registeredAgentType(instanceMeta?.agentType);
-    if (metaAgentType) {
-        return { id, installMode, driver: "runtime-adapter", agentType: metaAgentType, appSpec: appSpec ?? undefined, instanceMeta: instanceMeta ?? undefined };
-    }
-    const specAgentType = appSpecAgentType(appSpec);
-    if (specAgentType) {
-        return { id, installMode, driver: "runtime-adapter", agentType: specAgentType, appSpec: appSpec ?? undefined, instanceMeta: instanceMeta ?? undefined };
-    }
-    if (appRecord) {
-        const driver = isOllamaIdentity(id, appSpec, instanceMeta) ? "local-model" : "app-job";
-        return { id, installMode, driver, appSpec: appRecord.appSpec ?? undefined, instanceMeta: instanceMeta ?? undefined };
-    }
-    if (instanceMeta) {
-        const appType = typeof instanceMeta.app_type === "string" ? instanceMeta.app_type.trim() : "";
-        if (appType === "custom" || appType === "ollama")
-            return null;
-        const legacyAgentType = registeredAgentType(instanceMeta.app_spec_ref ? "custom" : "openclaw");
-        if (legacyAgentType) {
-            return { id, installMode: "legacy", driver: "runtime-adapter", agentType: legacyAgentType, instanceMeta };
-        }
-    }
-    return null;
-}
-export function resolveRuntimeIdentity(id) {
-    const now = Date.now();
-    const previous = cache.get(id);
-    try {
-        const fingerprint = computeFingerprint(id);
-        if (previous && previous.fingerprint === fingerprint)
-            return previous.value;
-        const value = resolveFresh(id);
-        cache.set(id, { fingerprint, value, resolvedAt: now });
-        return value;
-    }
-    catch {
-        if (previous && now - previous.resolvedAt <= CACHE_TTL_MS)
-            return previous.value;
-        const value = resolveFresh(id);
-        cache.set(id, { fingerprint: "", value, resolvedAt: now });
-        return value;
-    }
-}
-export function invalidateRuntimeIdentity(id) {
-    if (id)
-        cache.delete(id);
-    else
-        cache.clear();
-}
-//# sourceMappingURL=runtime-identity.js.map