@cocorograph/hub-agent 0.8.48 → 0.8.50

package/bin/hub-agent.mjs

@@ -37,8 +37,10 @@ import { resolveSyncTargets, syncBundleTargets } from "../src/hub-bundle.mjs"
 import { loadPlugins } from "../src/plugin-loader.mjs"
 import { uninstallPlugin } from "../src/plugin-uninstall.mjs"
 import {
+  canSuggestForcedRestart,
   installService,
   restartService,
+  restartWithPolicy,
   uninstallService,
 } from "../src/service-install.mjs"
 
@@ -231,18 +233,45 @@ program
 
 program
   .command("restart")
-  .description("install-service 済みの daemon を再起動 (macOS=launchctl kickstart / Linux=systemctl --user restart)")
-  .action(async () => {
+  .description("実行中の作業完了後に daemon を安全に再起動 (--force は即時再起動)")
+  .option("--force", "サービスマネージャーで即時再起動する")
+  .action(async (opts) => {
     try {
-      const r = await restartService()
-      console.log(`restarted: ${r.platform} ${r.path}`)
-      if (r.platform === "darwin") {
-        console.log(`label: ${r.label}`)
+      const restart = await restartWithPolicy({
+        force: !!opts.force,
+        deferredRestart: async () => {
+          const { requestDeferredRestart } = await import("../src/sibling-inject.mjs")
+          return requestDeferredRestart()
+        },
+        immediateRestart: restartService,
+      })
+      if (restart.mode === "immediate") {
+        const r = restart.result
+        console.log(`restarted immediately: ${r.platform} ${r.path}`)
+        if (r.platform === "darwin") {
+          console.log(`label: ${r.label}`)
+        } else {
+          console.log(`unit: ${r.unit}`)
+        }
       } else {
-        console.log(`unit: ${r.unit}`)
+        console.log("restart accepted: daemon will restart after active work completes")
       }
     } catch (err) {
       console.error(`restart failed: ${err.message}`)
+      if (err.code === "service_not_installed") {
+        console.error("Run `hub-agent install-service` before restarting.")
+      } else if (!opts.force && canSuggestForcedRestart(err)) {
+        if (err.code === "restart_rejected" &&
+            (err.daemonError === "invalid_request" || err.daemonError === "restart_unavailable")) {
+          console.error(
+            "The daemon may be an older version or the request contract may be unsupported. " +
+            "No immediate fallback was attempted.",
+          )
+        }
+        console.error(
+          "Check ~/.hub/agent.log first. Use `hub-agent restart --force` only if interrupting active work is acceptable.",
+        )
+      }
       process.exit(1)
     }
   })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocorograph/hub-agent",
-  "version": "0.8.48",
+  "version": "0.8.50",
   "description": "Hub Hosted Cockpit のローカル常駐 agent。Hub と outbound WSS で接続し、ローカルの Claude / Codex チャットと tmux セッションを中継する。",
   "type": "module",
   "license": "UNLICENSED",
@@ -18,7 +18,7 @@
   },
   "scripts": {
     "start": "node bin/hub-agent.mjs start",
-    "test": "node --test test/*.test.mjs",
+    "test": "node --test --test-concurrency=1 test/*.test.mjs",
     "check:publish-on-main": "node scripts/check-publish-on-main.mjs",
     "prepublishOnly": "node scripts/check-publish-on-main.mjs && npm test"
   },

package/src/claude-stream-bridge.mjs

@@ -3703,13 +3703,26 @@ export class ClaudeStreamBridge extends EventEmitter {
    *  観測は **通知の台帳**で行い、権威照会 `thread/backgroundTerminals/list` は使わない
    *  （実験 API の有効化が要るうえ、threadId ごとの照会なので子スレッドの背景コマンドを取りこぼす）。 */
   _isSessionProtected(session, now = Date.now()) {
-    if (!session) return false
+    return this._hasSessionWork(session, now) || this._liveTerminalCount(session) >= 2
+  }
+
+  /** warm保護から購読数だけを除いた、実作業の共通判定。 */
+  _hasSessionWork(session, now = Date.now()) {
+    if (!session || session._closed) return false
     if (session._busy) return true
-    if (Array.isArray(session._pendingMessages) && session._pendingMessages.length > 0) {
-      return true
+    if (Array.isArray(session._pendingMessages) && session._pendingMessages.length > 0) return true
+    return !!session._hasLiveTask?.(now)
+  }
+
+  /**
+   * daemon の deferred restart が待つべき実作業があるか。
+   * 多端末 subscribe は warm 保持には必要だが作業ではないため、ここでは数えない。
+   */
+  hasActiveWork(now = Date.now()) {
+    for (const { session } of this._liveCandidatesForCwd()) {
+      if (this._hasSessionWork(session, now)) return true
     }
-    if (session._hasLiveTask?.(now)) return true
-    return this._liveTerminalCount(session) >= 2
+    return false
   }
 
   /** 子⑤: warm 境界超過セッションを reap する（detach の softDetach onTimeout と同じ撤去処理）。 */

package/src/codex-artifact-template-picker.mjs

@@ -0,0 +1,198 @@
+import path from "node:path"
+import { lstat } from "node:fs/promises"
+
+import { resolveCodexWorkspaceDependencies } from "./codex-workspace-dependencies.mjs"
+
+export const ARTIFACT_TEMPLATE_CATALOG_MAX_ITEMS = 100
+export const ARTIFACT_TEMPLATE_CATALOG_MAX_BYTES = 24_000
+export const ARTIFACT_TEMPLATE_DESCRIPTION_MAX_CODEPOINTS = 600
+
+const TEMPLATE_NAME_RE = /^(?:[^:]+:)?artifact-template-[a-z0-9][a-z0-9._-]*$/
+const PICKER_CONFIG_KEY = "mcp_servers.openai_artifact_template_picker"
+const DARWIN_RESOURCES_PATH = "/Applications/ChatGPT.app/Contents/Resources"
+
+export class CodexArtifactTemplatePickerError extends Error {
+  constructor(code, message, options = {}) {
+    super(message, options)
+    this.name = "CodexArtifactTemplatePickerError"
+    this.code = code
+  }
+}
+
+function fail(code, message, cause) {
+  throw new CodexArtifactTemplatePickerError(code, message, cause ? { cause } : undefined)
+}
+
+function diagnostic(code, detail = {}) {
+  return { code, ...detail }
+}
+
+function priorityOf(skillName) {
+  if (skillName.startsWith("openai-templates:")) return 2
+  return skillName.includes(":") ? 1 : 0
+}
+
+function normalizedPathKey(skillPath, platform) {
+  // Desktop does not establish case-folding as part of its contract. Normalize separators and
+  // dot segments only, preserving case and the original path carried in the catalog.
+  return platform === "win32" ? path.win32.normalize(skillPath) : path.posix.normalize(skillPath)
+}
+
+function codepointPrefix(value, limit) {
+  return Array.from(value).slice(0, limit).join("")
+}
+
+function optionalTrimmed(value) {
+  return typeof value === "string" ? value.trim() : ""
+}
+
+function catalogCandidate(record) {
+  if (
+    !record ||
+    typeof record !== "object" ||
+    Array.isArray(record) ||
+    typeof record.name !== "string"
+  ) {
+    return { error: diagnostic("ARTIFACT_TEMPLATE_SKILL_METADATA_INVALID") }
+  }
+  if (!TEMPLATE_NAME_RE.test(record.name)) return { unrelated: true }
+  if (typeof record.path !== "string" || typeof record.enabled !== "boolean") {
+    return { error: diagnostic("ARTIFACT_TEMPLATE_SKILL_METADATA_INVALID") }
+  }
+  if (record.enabled !== true) return { disabled: true }
+  // skills/list is authoritative. Do not reinterpret, normalize, or derive this SKILL.md path.
+  if (!path.isAbsolute(record.path)) {
+    return { error: diagnostic("ARTIFACT_TEMPLATE_SKILL_PATH_INVALID", { skillName: record.name }) }
+  }
+  const description = optionalTrimmed(record.description)
+    || optionalTrimmed(record.interface?.shortDescription)
+    || optionalTrimmed(record.interface?.displayName)
+    || record.name
+  return {
+    candidate: {
+      skillName: record.name,
+      skillPath: record.path,
+      description: codepointPrefix(description, ARTIFACT_TEMPLATE_DESCRIPTION_MAX_CODEPOINTS),
+      priority: priorityOf(record.name),
+    },
+  }
+}
+
+/**
+ * Convert app-server skills/list SkillMetadata records to the Desktop-compatible picker catalog.
+ * The caller supplies the exact response records; this module deliberately does not scan plugin
+ * caches, personal skill directories, or config.toml to second-guess Codex enablement.
+ */
+export function collectCodexArtifactTemplateCatalog({ skills = [], platform = process.platform } = {}) {
+  const diagnostics = []
+  if (!Array.isArray(skills)) {
+    return {
+      catalog: [],
+      diagnostics: [diagnostic("ARTIFACT_TEMPLATE_SKILLS_LIST_INVALID")],
+    }
+  }
+
+  const rawCandidates = []
+  for (const record of skills) {
+    const result = catalogCandidate(record)
+    if (result.error) diagnostics.push(result.error)
+    else if (result.candidate) rawCandidates.push(result.candidate)
+  }
+  rawCandidates.sort((a, b) => b.priority - a.priority)
+
+  const catalog = []
+  let catalogBytes = 2 // JSON array brackets: []
+  const names = new Set()
+  const paths = new Set()
+  for (const { priority: _priority, ...candidate } of rawCandidates) {
+    const pathKey = normalizedPathKey(candidate.skillPath, platform)
+    if (names.has(candidate.skillName) || paths.has(pathKey)) {
+      diagnostics.push(diagnostic("ARTIFACT_TEMPLATE_SKILL_DUPLICATE", {
+        skillName: candidate.skillName,
+        skillPath: candidate.skillPath,
+      }))
+      continue
+    }
+    if (catalog.length >= ARTIFACT_TEMPLATE_CATALOG_MAX_ITEMS) {
+      diagnostics.push(diagnostic("ARTIFACT_TEMPLATE_CATALOG_ITEM_LIMIT", { skillName: candidate.skillName }))
+      continue
+    }
+    const candidateBytes = Buffer.byteLength(JSON.stringify(candidate), "utf8")
+    const nextBytes = catalogBytes + (catalog.length > 0 ? 1 : 0) + candidateBytes
+    if (nextBytes > ARTIFACT_TEMPLATE_CATALOG_MAX_BYTES) {
+      diagnostics.push(diagnostic("ARTIFACT_TEMPLATE_CATALOG_BYTE_LIMIT", { skillName: candidate.skillName }))
+      continue
+    }
+    catalog.push(candidate)
+    catalogBytes = nextBytes
+    names.add(candidate.skillName)
+    paths.add(pathKey)
+  }
+  return { catalog, diagnostics }
+}
+
+async function isFile(candidate, lstatImpl) {
+  try {
+    const value = await lstatImpl(candidate)
+    return value.isFile() && !value.isSymbolicLink()
+  } catch {
+    return false
+  }
+}
+
+async function resolveResourcesPath({ env, platform, lstatImpl }) {
+  const explicit = env.CODEX_ELECTRON_RESOURCES_PATH
+  if (explicit) {
+    if (!path.isAbsolute(explicit)) {
+      fail("CODEX_ARTIFACT_RESOURCES_PATH_INVALID", "CODEX_ELECTRON_RESOURCES_PATH must be absolute")
+    }
+    return path.normalize(explicit)
+  }
+  if (platform === "darwin") {
+    const server = path.join(DARWIN_RESOURCES_PATH, "artifact-template-picker", "server.mjs")
+    if (await isFile(server, lstatImpl)) return DARWIN_RESOURCES_PATH
+  }
+  fail("CODEX_ARTIFACT_RESOURCES_PATH_UNAVAILABLE", "Codex Electron resources path is unavailable")
+}
+
+export async function preflightCodexArtifactTemplatePicker({
+  env = process.env,
+  platform = process.platform,
+  lstatImpl = lstat,
+} = {}) {
+  const resourcesPath = await resolveResourcesPath({ env, platform, lstatImpl })
+  const serverPath = path.join(resourcesPath, "artifact-template-picker", "server.mjs")
+  if (!await isFile(serverPath, lstatImpl)) {
+    fail("CODEX_ARTIFACT_TEMPLATE_PICKER_MISSING", "Codex artifact template picker server is missing")
+  }
+  return { resourcesPath, serverPath }
+}
+
+/** Return the dotted thread/start config shape consumed by Codex app-server. */
+export async function buildCodexArtifactTemplatePickerConfig({
+  env = process.env,
+  platform = process.platform,
+  skills = [],
+  resolveWorkspaceDependencies = resolveCodexWorkspaceDependencies,
+  lstatImpl = lstat,
+  preflight,
+  onDiagnostic,
+} = {}) {
+  const verified = preflight || await preflightCodexArtifactTemplatePicker({ env, platform, lstatImpl })
+  const { serverPath } = verified
+  const runtime = await resolveWorkspaceDependencies()
+  if (typeof runtime?.nodePath !== "string" || !path.isAbsolute(runtime.nodePath)) {
+    fail("CODEX_ARTIFACT_RUNTIME_NODE_INVALID", "Codex primary runtime did not return an absolute nodePath")
+  }
+  const { catalog, diagnostics } = collectCodexArtifactTemplateCatalog({ skills, platform })
+  for (const item of diagnostics) onDiagnostic?.(item)
+  return {
+    [PICKER_CONFIG_KEY]: {
+      command: runtime.nodePath,
+      args: [serverPath],
+      env: {
+        CODEX_ARTIFACT_TEMPLATE_SKILLS: JSON.stringify(catalog),
+      },
+    },
+  }
+}

package/src/codex-dynamic-tools.mjs

@@ -0,0 +1,191 @@
+import path from "node:path"
+
+import { resolveCodexWorkspaceDependencies } from "./codex-workspace-dependencies.mjs"
+
+const NAMESPACE = "codex_app"
+const LOAD_WORKSPACE_DEPENDENCIES = "load_workspace_dependencies"
+const COMPLETED_CALL_LEDGER_MAX = 256
+
+const EMPTY_OBJECT_SCHEMA = Object.freeze({
+  type: "object",
+  properties: {},
+  additionalProperties: false,
+})
+
+export const CODEX_DYNAMIC_TOOLS = Object.freeze([
+  Object.freeze({
+    type: "namespace",
+    name: NAMESPACE,
+    description: "Codex standard runtime tools provided by the Cockpit host.",
+    tools: Object.freeze([
+      Object.freeze({
+        type: "function",
+        name: LOAD_WORKSPACE_DEPENDENCIES,
+        description: "Resolve the verified Codex primary runtime dependencies for artifact skills.",
+        inputSchema: EMPTY_OBJECT_SCHEMA,
+      }),
+    ]),
+  }),
+])
+
+function inputText(text) {
+  return { contentItems: [{ type: "inputText", text }], success: true }
+}
+
+const REQUIRED_INVENTORY_FIELDS = Object.freeze([
+  ["bundleVersion", "Bundle version", false],
+  ["gitPath", "Git executable", true],
+  ["nodePath", "Node.js executable", false],
+  ["nodeModulesPath", "Node.js packages", false],
+  ["pnpmPath", "pnpm executable", true],
+  ["pythonPath", "Python executable", false],
+  ["pythonLibrariesPath", "Python packages", false],
+  ["overrideBinPath", "Override binaries", false],
+  ["fallbackBinPath", "Fallback binaries", false],
+])
+
+function invalidInventory() {
+  const error = new Error("Codex workspace dependency inventory is invalid")
+  error.code = "CODEX_DYNAMIC_TOOL_INVENTORY_INVALID"
+  throw error
+}
+
+function inventoryValue(inventory, field, optional) {
+  const value = inventory[field]
+  if (optional && (value === null || value === undefined)) return null
+  if (!isNonEmptyString(value) || /[\r\n`]/.test(value)) invalidInventory()
+  if (field !== "bundleVersion" && !path.isAbsolute(value)) invalidInventory()
+  return value
+}
+
+function inlineCode(value) {
+  return `\`${value}\``
+}
+
+/** Format only the canonical resolver inventory; compatibility aliases are never substituted. */
+export function formatCodexWorkspaceDependencies(inventory) {
+  if (!inventory || typeof inventory !== "object" || Array.isArray(inventory)) invalidInventory()
+  const lines = [
+    "Workspace dependencies are available for this local desktop thread.",
+    "",
+    "### Workspace Dependencies",
+    "",
+    "Use these bundled paths for sheets, slides, documents, PDFs, images, or browser automation:",
+    "",
+  ]
+  for (const [field, label, optional] of REQUIRED_INVENTORY_FIELDS) {
+    const value = inventoryValue(inventory, field, optional)
+    if (value !== null) lines.push(`- ${label}: ${inlineCode(value)}`)
+  }
+  return lines.join("\n")
+}
+
+function failure(text) {
+  return { contentItems: [{ type: "inputText", text }], success: false }
+}
+
+export function codexDynamicToolFailure(code) {
+  const safeCode = sanitizeCodexDynamicErrorCode(code)
+  return failure(`Dynamic tool call failed (${safeCode})`)
+}
+
+export function sanitizeCodexDynamicErrorCode(value, fallback = "CODEX_DYNAMIC_TOOL_ERROR") {
+  return typeof value === "string" && value.length <= 128 && /^[A-Z0-9_]+$/.test(value)
+    ? value
+    : fallback
+}
+
+export function sanitizeCodexDynamicToolName(value) {
+  return typeof value === "string"
+    && value.length >= 1
+    && value.length <= 128
+    && /^[A-Za-z0-9_.:-]+$/.test(value)
+    ? value
+    : "unknown"
+}
+
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0
+}
+
+function validateCall(params) {
+  if (!params || typeof params !== "object" || Array.isArray(params)) {
+    return { ok: false, code: "INVALID_CALL", tool: "unknown" }
+  }
+  const tool = sanitizeCodexDynamicToolName(params.tool)
+  if (
+    !isNonEmptyString(params.threadId) ||
+    !isNonEmptyString(params.callId) ||
+    !isNonEmptyString(params.turnId)
+  ) {
+    return { ok: false, code: "INVALID_CALL", tool }
+  }
+  if (params.namespace !== NAMESPACE) {
+    return { ok: false, code: "UNKNOWN_NAMESPACE", tool }
+  }
+  if (params.tool !== LOAD_WORKSPACE_DEPENDENCIES) {
+    return { ok: false, code: "UNKNOWN_TOOL", tool }
+  }
+  if (
+    !params.arguments ||
+    typeof params.arguments !== "object" ||
+    Array.isArray(params.arguments) ||
+    Object.keys(params.arguments).length !== 0
+  ) {
+    return { ok: false, code: "INVALID_ARGUMENTS", tool }
+  }
+  return { ok: true, tool }
+}
+
+/**
+ * A per-session executor for host-provided Codex dynamic tools.
+ * Recent results are retained in a bounded replay window so transport retries cannot execute a
+ * resolver twice without allowing an unbounded session-lifetime ledger.
+ */
+export function createCodexDynamicToolExecutor({
+  resolveWorkspaceDependencies = resolveCodexWorkspaceDependencies,
+  logger,
+} = {}) {
+  const calls = new Map()
+
+  const executeOnce = async (params) => {
+    const validation = validateCall(params)
+    if (!validation.ok) {
+      logger?.warn?.(
+        { tool: validation.tool, error_code: validation.code },
+        "codex dynamic tool call rejected",
+      )
+      return failure(`Dynamic tool call rejected (${validation.code})`)
+    }
+
+    try {
+      const dependencies = await resolveWorkspaceDependencies()
+      return inputText(formatCodexWorkspaceDependencies(dependencies))
+    } catch (error) {
+      const code = sanitizeCodexDynamicErrorCode(error?.code)
+      logger?.warn?.(
+        { tool: validation.tool, error_code: code },
+        "codex dynamic tool call failed",
+      )
+      return failure(`Workspace dependency resolution failed (${code})`)
+    }
+  }
+
+  return {
+    definitions: CODEX_DYNAMIC_TOOLS,
+    execute(params) {
+      const threadId = isNonEmptyString(params?.threadId) ? params.threadId : null
+      const callId = isNonEmptyString(params?.callId) ? params.callId : null
+      if (!threadId || !callId) return executeOnce(params)
+      const key = JSON.stringify([threadId, callId])
+      const existing = calls.get(key)
+      if (existing) return existing
+      const pending = executeOnce(params)
+      calls.set(key, pending)
+      if (calls.size > COMPLETED_CALL_LEDGER_MAX) {
+        calls.delete(calls.keys().next().value)
+      }
+      return pending
+    },
+  }
+}