@v587d/capital-generation 2.11.1 → 2.13.0

package/automation/defaults.js

@@ -0,0 +1,71 @@
+/**
+ * Automation deployment defaults. Read once at the call site (`settings.js`), never frozen into
+ * the scheduler at mount time: the settings card may change between ticks.
+ */
+export const DEFAULT_TICK_MS = 60_000
+export const MIN_TICK_MS = 30_000
+export const MAX_TICK_MS = 3_600_000
+
+export const DEFAULT_RUN_TIMEOUT_MINUTES = 30
+export const MIN_RUN_TIMEOUT_MINUTES = 5
+export const MAX_RUN_TIMEOUT_MINUTES = 120
+
+export const DEFAULT_IDLE_TIMEOUT_MINUTES = 5
+export const MIN_IDLE_TIMEOUT_MINUTES = 1
+export const MAX_IDLE_TIMEOUT_MINUTES = 30
+
+// Real multi-agent research runs use hundreds of tool calls (subagent calls included). These
+// limits bound runaway loops, not normal work; wall-clock and idle remain the primary guards.
+export const DEFAULT_MAX_STEPS = 300
+export const MIN_MAX_STEPS = 10
+export const MAX_MAX_STEPS = 2_000
+
+export const DEFAULT_MAX_TOOL_CALLS = 1_200
+export const MIN_MAX_TOOL_CALLS = 10
+export const MAX_MAX_TOOL_CALLS = 6_000
+
+export const DEFAULT_OWNER_LEASE_MS = 90_000
+export const MIN_OWNER_LEASE_MS = 30_000
+export const MAX_OWNER_LEASE_MS = 600_000
+
+export const DEFAULT_CATCH_UP_MS = 10 * 60_000
+export const CANCEL_GRACE_MS = 15_000
+export const QUIET_SETTLE_MS = 750
+
+export const MAX_RUNS_PER_TASK = 200
+export const MAX_RUNS_PER_PROFILE = 2_000
+export const MAX_NOTIFICATIONS_PER_PROFILE = 200
+export const MAX_ERRORS_PER_RUN = 20
+
+export const MAX_TITLE_CHARS = 120
+export const MAX_DESCRIPTION_CHARS = 500
+export const MAX_INSTRUCTION_CHARS = 12_000
+export const MAX_ERROR_MESSAGE_CHARS = 500
+export const MAX_REQUEST_BODY_BYTES = 64 * 1024
+
+export const DEFAULT_AUTOMATION_SETTINGS = {
+  tickMs: DEFAULT_TICK_MS,
+  runTimeoutMinutes: DEFAULT_RUN_TIMEOUT_MINUTES,
+  idleTimeoutMinutes: DEFAULT_IDLE_TIMEOUT_MINUTES,
+  maxSteps: DEFAULT_MAX_STEPS,
+  maxToolCalls: DEFAULT_MAX_TOOL_CALLS,
+  inAppNotifications: true,
+}
+
+export const RUN_STATUSES = [
+  'queued',
+  'starting',
+  'running',
+  'succeeded',
+  'failed',
+  'canceled',
+  'timed_out',
+  'blocked_requires_user',
+  'unknown_after_restart',
+  'skipped_overlap',
+  'skipped_calendar_unavailable',
+  'missed',
+]
+
+export const ACTIVE_RUN_STATUSES = ['queued', 'starting', 'running']
+export const TERMINAL_RUN_STATUSES = RUN_STATUSES.filter((status) => !ACTIVE_RUN_STATUSES.includes(status))

package/automation/index.js

@@ -0,0 +1,183 @@
+/**
+ * Host row `capital-automation`: fixed domain, profile-filtered API, one cross-process
+ * scheduler lease, and the browser page mounted on the host plane. The official
+ * `ui-schedule` row and its `schedules` identities are untouched.
+ */
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { createRunRunner, buildRunPrompt, sessionTitleOf } from './runner.js'
+import { createScheduler } from './scheduler.js'
+import { createAutomationService, AutomationError } from './service.js'
+import { createAutomationStore, domainSpec, ROUTE_PATH } from './store.js'
+import { createAutomationRouteHandler } from './route.js'
+import { resolveAutomationSettings } from './settings.js'
+import { installAutomationPolicy } from './policy.js'
+import { createTradingCalendar } from './calendar.js'
+import { createWorkspaceCatalog } from './workspaces.js'
+import { sanitizeMessage } from './redact.js'
+
+export const name = 'capital-automation'
+export { ROUTE_PATH, domainSpec, buildRunPrompt, sessionTitleOf }
+
+function versionOf() {
+  try {
+    return JSON.parse(readFileSync(new URL('./package.json', import.meta.url), 'utf8')).version ?? '0.0.0'
+  } catch {
+    return '0.0.0'
+  }
+}
+
+function safeSegment(value) {
+  return String(value).replace(/[^A-Za-z0-9._-]+/g, '_').slice(0, 120)
+}
+
+/**
+ * Build the runtime without Cordis services. Exported for tests and for the desktop carrier
+ * that supplies its own HTTP/auth plane.
+ */
+export function createAutomationRuntime(options) {
+  const { ctx, profile, storageDomain, settings, now = () => Date.now(), logger, version = versionOf() } = options
+  const calendar = options.calendar ?? createTradingCalendar()
+  const getSettings = typeof settings === 'function' ? settings : () => resolveAutomationSettings(ctx, settings)
+  const rawProfileName = String(profile.name)
+  const displayName = rawProfileName.slice(0, 200)
+  const home = profile.home ?? profile.dir ?? process.cwd()
+  const runDir = profile.runDir ?? join(home, 'automation-workspace', safeSegment(displayName))
+  const ownerDir = profile.ownerDir ?? join(home, 'storages', 'capital-automation-locks')
+  const policyContext = options.policyContext ?? ctx
+  const workspaces = createWorkspaceCatalog({ ctx, displayName, runDir, logger })
+  const store = createAutomationStore({
+    openDomain: () => storageDomain.open(domainSpec),
+    profile: { name: rawProfileName },
+    now,
+    calendar,
+  })
+  const runner = createRunRunner({
+    ctx,
+    store,
+    settings: getSettings,
+    profile: { displayName, runDir },
+    workspaces,
+    now,
+    logger,
+  })
+  const scheduler = createScheduler({
+    store,
+    runner,
+    calendar,
+    profile: { ownerDir },
+    getSettings,
+    now,
+    logger,
+  })
+  const service = createAutomationService({
+    store,
+    scheduler,
+    runner,
+    calendar,
+    profile: { displayName },
+    workspaces,
+    version,
+    settings: getSettings,
+    now,
+  })
+  runner.installListeners()
+  if (typeof policyContext?.inject === 'function') {
+    policyContext.inject(['tools'], (toolsCtx) => {
+      installAutomationPolicy({ ctx: toolsCtx, runner, logger })
+    })
+  }
+  return { store, runner, scheduler, service, calendar, workspaces, profile: { displayName, runDir, ownerDir } }
+}
+
+function authorizeFactory(ctx) {
+  return (req) => {
+    let connection
+    try {
+      connection = ctx.get('connection')
+    } catch {
+      return 401
+    }
+    if (connection === undefined || connection === null) return 401
+    if (typeof connection.requestRejection !== 'function') return 401
+    return connection.requestRejection(req)
+  }
+}
+
+function unavailable(code, message) {
+  return Promise.reject(new AutomationError(code, message, 503))
+}
+
+/** Route proxy: the page exists before the profile/storage fibers settle, and says so. */
+function lazyService(getService) {
+  return new Proxy({}, {
+    get(_target, property) {
+      return async (...args) => {
+        let service
+        try {
+          service = await getService()
+        } catch {
+          return unavailable('automation_unavailable', '投研自动化服务尚未就绪。')
+        }
+        const method = service?.[property]
+        if (typeof method !== 'function') return unavailable('automation_unavailable', '投研自动化服务尚未就绪。')
+        return method(...args)
+      }
+    },
+  })
+}
+
+export function apply(ctx) {
+  const logger = ctx.logger
+  let activeService
+
+  function currentService() {
+    return activeService
+  }
+
+  ctx.inject(['profileContext', 'storageDomain'], (appCtx) => {
+    let created
+    try {
+      const profileContext = appCtx.profileContext
+      created = createAutomationRuntime({
+        ctx,
+        profile: profileContext,
+        storageDomain: appCtx.storageDomain,
+        policyContext: appCtx,
+        logger,
+      })
+      activeService = created.service
+      created.scheduler.start()
+        .then(() => logger?.info?.(`capital-automation: scheduler ${created.scheduler.status().state}`))
+        .catch((error) => logger?.error?.(`capital-automation: scheduler 启动失败：${String(error)}`))
+      appCtx.effect(() => async () => {
+        if (activeService === created.service) {
+          activeService = undefined
+        }
+        await created.scheduler.stop().catch(() => {})
+        await created.runner.dispose?.()
+        await created.store.close().catch(() => {})
+      }, 'capital-automation: runtime')
+    } catch (error) {
+      logger?.error?.(`capital-automation: 运行时组装失败：${sanitizeMessage(String(error))}`)
+    }
+  })
+
+  const service = lazyService(currentService)
+  const handler = createAutomationRouteHandler(service, {
+    authorize: authorizeFactory(ctx),
+    logger,
+  })
+
+  ctx.inject(['webServer'], (webCtx) => {
+    webCtx.effect(
+      () => webCtx.webServer.register({ kind: 'prefix', path: ROUTE_PATH, handler }),
+      'capital-automation: route',
+    )
+  })
+
+  ctx.logger?.info?.('capital-automation: host row active (page + /capital-automation)')
+}
+
+export { resolveAutomationSettings }

package/automation/owner.js

@@ -0,0 +1,222 @@
+import { randomUUID } from 'node:crypto'
+import { mkdir, open, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+
+function safeSegment(value) {
+  return String(value).replace(/[^A-Za-z0-9._-]+/g, '_').slice(0, 120)
+}
+
+function ownerFile(ownerDir) {
+  return join(ownerDir, 'owner.json')
+}
+
+async function readOwnerFile(ownerDir, expectedProfileKey) {
+  try {
+    const text = await readFile(ownerFile(ownerDir), 'utf8')
+    const value = JSON.parse(text)
+    if (value === null || typeof value !== 'object') return undefined
+    if (typeof value.ownerId !== 'string' || typeof value.expiresAt !== 'number') return undefined
+    if (expectedProfileKey !== undefined && value.profileKey !== expectedProfileKey) return undefined
+    return value
+  } catch {
+    return undefined
+  }
+}
+
+/** Read the active owner without following a renamed old root. */
+async function readOwner(lockDir, expectedProfileKey) {
+  try {
+    const entries = await readdir(lockDir, { withFileTypes: true })
+    const owners = []
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue
+      const value = await readOwnerFile(join(lockDir, entry.name), expectedProfileKey)
+      if (value !== undefined) owners.push(value)
+    }
+    // Read old-format records during the one-release migration window.
+    const legacy = await readOwnerFile(lockDir, expectedProfileKey)
+    if (legacy !== undefined) owners.push(legacy)
+    owners.sort((left, right) => (right.expiresAt ?? 0) - (left.expiresAt ?? 0))
+    return owners[0]
+  } catch {
+    return undefined
+  }
+}
+
+async function atomicWrite(file, value) {
+  const temp = `${file}.${process.pid}.${randomUUID()}.tmp`
+  await writeFile(temp, `${JSON.stringify(value)}\n`, { mode: 0o600 })
+  await rename(temp, file)
+}
+
+export function createOwnerLease(options) {
+  const {
+    directory,
+    profileKey,
+    ownerId,
+    leaseMs,
+    now = () => Date.now(),
+    random = () => randomUUID(),
+  } = options
+  // The root is only the arbitration point. Each lease gets a private child directory, so a
+  // stale process keeps addressing the renamed old root and can never write into its successor.
+  const lockDir = join(directory, `capital_automation.${safeSegment(profileKey)}.lock`)
+  let ownedDir
+  let held = false
+  let token
+
+  async function ensureDirectory() {
+    await mkdir(directory, { recursive: true, mode: 0o700 })
+  }
+
+  async function writeClaim() {
+    if (ownedDir === undefined || token === undefined) throw new Error('owner lease is not claimed')
+    const at = now()
+    await atomicWrite(ownerFile(ownedDir), {
+      ownerId,
+      fencingToken: token,
+      profileKey,
+      acquiredAt: at,
+      heartbeatAt: at,
+      expiresAt: at + leaseMs,
+    })
+  }
+
+  async function claimEmptyRoot() {
+    token = `${Date.now().toString(36)}-${String(random()).slice(0, 8)}`
+    const candidate = join(lockDir, `lease-${safeSegment(ownerId)}-${safeSegment(token)}`)
+    await mkdir(candidate, { mode: 0o700 })
+    ownedDir = candidate
+    try {
+      await writeClaim()
+      held = true
+      return true
+    } catch (error) {
+      ownedDir = undefined
+      token = undefined
+      await rm(candidate, { recursive: true, force: true }).catch(() => {})
+      throw error
+    }
+  }
+
+  async function acquire() {
+    if (held) return true
+    await ensureDirectory()
+    let createdRoot = false
+    try {
+      await mkdir(lockDir, { mode: 0o700 })
+      createdRoot = true
+    } catch (error) {
+      if (error?.code !== 'EEXIST') throw error
+    }
+    if (createdRoot) return claimEmptyRoot()
+
+    const incumbent = await readOwner(lockDir, profileKey)
+    if (incumbent !== undefined && Number.isFinite(incumbent.expiresAt) && incumbent.expiresAt > now()) {
+      return false
+    }
+    // Only the contender that wins this rename may install a replacement root. Any old owner
+    // still holding the previous child path can write there, but that path is now stale.
+    const stale = `${lockDir}.stale-${process.pid}-${String(random()).slice(0, 8)}`
+    try {
+      await rename(lockDir, stale)
+    } catch {
+      return false
+    }
+    try {
+      await mkdir(lockDir, { mode: 0o700 })
+      return await claimEmptyRoot()
+    } catch (error) {
+      if (error?.code !== 'EEXIST') throw error
+      return false
+    } finally {
+      await rm(stale, { recursive: true, force: true }).catch(() => {})
+    }
+  }
+
+  async function renew() {
+    if (!held || ownedDir === undefined || token === undefined) return false
+    const current = await readOwnerFile(ownedDir, profileKey)
+    const active = await readOwner(lockDir, profileKey)
+    if (current?.ownerId !== ownerId || current?.fencingToken !== token
+      || active?.ownerId !== ownerId || active?.fencingToken !== token) {
+      held = false
+      return false
+    }
+    if (!Number.isFinite(current.expiresAt) || current.expiresAt <= now()
+      || !Number.isFinite(active.expiresAt) || active.expiresAt <= now()) {
+      held = false
+      return false
+    }
+    try {
+      await writeClaim()
+      const afterWrite = await readOwner(lockDir, profileKey)
+      if (afterWrite?.ownerId !== ownerId || afterWrite?.fencingToken !== token) {
+        held = false
+        return false
+      }
+      return true
+    } catch {
+      held = false
+      return false
+    }
+  }
+
+  async function release() {
+    if (!held) return
+    held = false
+    const previousDir = ownedDir
+    const previousToken = token
+    ownedDir = undefined
+    token = undefined
+    const current = await readOwnerFile(previousDir, profileKey)
+    if (current?.ownerId !== ownerId || current?.fencingToken !== previousToken) return
+    // Do not remove the root: deleting it races a successor. An empty root is safely renamed by
+    // the next contender after it observes that no live child lease remains.
+    await rm(previousDir, { recursive: true, force: true }).catch(() => {})
+  }
+
+  return {
+    lockDir,
+    get held() {
+      return held
+    },
+    get fencingToken() {
+      return token
+    },
+    acquire,
+    renew,
+    release,
+    read: () => readOwner(lockDir, profileKey),
+    async isCurrent() {
+      if (!held || ownedDir === undefined || token === undefined) return false
+      const current = await readOwnerFile(ownedDir, profileKey)
+      const active = await readOwner(lockDir, profileKey)
+      return current?.ownerId === ownerId
+        && current?.fencingToken === token
+        && active?.ownerId === ownerId
+        && active?.fencingToken === token
+        && Number.isFinite(current.expiresAt)
+        && current.expiresAt > now()
+        && Number.isFinite(active.expiresAt)
+        && active.expiresAt > now()
+    },
+  }
+}
+
+/** Test hook: create a foreign lease without racing the public acquire path. */
+export async function writeForeignLease(directory, profileKey, owner) {
+  const lockDir = join(directory, `capital_automation.${safeSegment(profileKey)}.lock`)
+  await mkdir(lockDir, { recursive: true, mode: 0o700 })
+  const child = join(lockDir, `lease-${safeSegment(owner.ownerId ?? 'foreign')}-${safeSegment(owner.fencingToken ?? randomUUID())}`)
+  await mkdir(child, { mode: 0o700 })
+  await atomicWrite(ownerFile(child), owner)
+  return lockDir
+}
+
+/** Touch an empty marker file so callers can prove the directory exists before opening a domain. */
+export async function ensureOwnerDirectory(directory) {
+  await mkdir(directory, { recursive: true, mode: 0o700 })
+  const marker = await open(join(directory, '.keep'), 'a', 0o600)
+  await marker.close()
+}

package/automation/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@v587d/capital-automation",
+  "version": "2.13.0",
+  "description": "CapGen 投研自动化：独立 host bundle（固定 capital_automation 域、单 scheduler owner、/capital-automation 路由与浏览器页面）。",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "default": "./index.js"
+    },
+    "./client": {
+      "default": "./client.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-primitives",
+        "@deepseek-ai/dsh-client-ui-workspace"
+      ]
+    }
+  },
+  "dependencies": {
+    "zod": "^4.5.4"
+  },
+  "files": [
+    "index.js",
+    "defaults.js",
+    "schema.js",
+    "builtins.js",
+    "time.js",
+    "calendar.js",
+    "owner.js",
+    "store.js",
+    "service.js",
+    "runner.js",
+    "scheduler.js",
+    "workspaces.js",
+    "policy.js",
+    "route.js",
+    "settings.js",
+    "redact.js",
+    "client.js",
+    "package.json"
+  ]
+}

package/automation/policy.js

@@ -0,0 +1,105 @@
+/**
+ * Hard call-level policy for unattended runs. Identity is the session id registered by the
+ * runner: a tool call is constrained only when its exact Agent session belongs to a live run.
+ * Role composition already closes each child's tool surface; this layer removes the two
+ * interactions that composition cannot express (asking the user and writing files/privilege).
+ */
+export const BLOCKED_TOOL_NAMES = ['ask_user_question', 'write', 'edit']
+export const SHELL_TOOL_NAMES = ['bash', 'pwsh', 'run_code']
+
+const INSTALLED = new WeakMap()
+
+function runnerOf(value) {
+  try {
+    return typeof value === 'function' ? value() : value
+  } catch {
+    return undefined
+  }
+}
+
+function isRecord(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+export function automationGuardReason(exec, runner) {
+  const name = exec?.name
+  if (typeof name !== 'string') return undefined
+  const activeRunner = runnerOf(runner)
+  const sessionId = exec?.agent?.session?.id
+  if (typeof sessionId !== 'string' || typeof activeRunner?.hasAutomationSession !== 'function' || !activeRunner.hasAutomationSession(sessionId)) return undefined
+  if (BLOCKED_TOOL_NAMES.includes(name)) {
+    const reason = name === 'ask_user_question'
+      ? '无人值守运行不能向用户提问：请基于现有信息采用保守口径继续，并在最终答复开头写明「需要用户确认」的缺口。'
+      : `无人值守运行不能写文件（${name}）：请把结论写在最终答复中，不要修改工作区。`
+    activeRunner.noteGuardDenied(sessionId, name, reason)
+    return reason
+  }
+  if (SHELL_TOOL_NAMES.includes(name)) {
+    const args = isRecord(exec.arguments) ? exec.arguments : undefined
+    if (args?.sandbox_permissions !== undefined || args?.justification !== undefined) {
+      const reason = '无人值守运行不能申请沙箱提权：请只读执行，缺文件或权限时如实说明。'
+      activeRunner.noteGuardDenied(sessionId, name, reason)
+      return reason
+    }
+  }
+  return undefined
+}
+
+export function installAutomationPolicy({ ctx, runner, logger }) {
+  const root = ctx.root ?? ctx
+  if (root === null || (typeof root !== 'object' && typeof root !== 'function')) return
+  const existing = INSTALLED.get(root)
+  if (existing !== undefined) {
+    existing.runner = runner
+    existing.generation += 1
+    const generation = existing.generation
+    const cleanup = () => {
+      if (INSTALLED.get(root) !== existing || existing.generation !== generation) return
+      try {
+        if (typeof existing.disposeGuard === 'function') existing.disposeGuard()
+      } finally {
+        INSTALLED.delete(root)
+      }
+    }
+    if (typeof ctx.effect === 'function') {
+      ctx.effect(() => cleanup, 'capital-automation: unattended policy')
+      return
+    }
+    return cleanup
+  }
+  let tools
+  try {
+    tools = ctx.get?.('tools') ?? ctx.tools
+  } catch {
+    tools = undefined
+  }
+  if (tools === undefined || typeof tools.guard !== 'function') {
+    logger?.warn?.('capital-automation: tools.guard 不可用，无人值守工具闸门未安装')
+    return
+  }
+  const record = { runner, generation: 1, disposeGuard: undefined }
+  const install = () => {
+    try {
+      record.disposeGuard = tools.guard((exec) => automationGuardReason(exec, record.runner))
+      INSTALLED.set(root, record)
+      logger?.info?.('capital-automation: 无人值守工具闸门已安装（ask_user_question / write / edit / shell 提权）')
+    } catch (error) {
+      logger?.warn?.(`capital-automation: 无人值守工具闸门安装失败：${String(error)}`)
+      return undefined
+    }
+    const generation = record.generation
+    return () => {
+      if (INSTALLED.get(root) !== record || record.generation !== generation) return
+      try {
+        if (typeof record.disposeGuard === 'function') record.disposeGuard()
+      } finally {
+        INSTALLED.delete(root)
+      }
+    }
+  }
+  if (typeof ctx.effect === 'function') {
+    ctx.effect(install, 'capital-automation: unattended policy')
+    return
+  }
+  return install()
+}

package/automation/redact.js

@@ -0,0 +1,25 @@
+/**
+ * Error text crossing the storage/wire boundary. Keep the user-readable cause, remove credentials,
+ * control bytes and host paths; model/tool payloads never enter this function.
+ */
+const TOKEN_PATTERNS = [
+  /\bBearer\s+[A-Za-z0-9._~+/-]+=*/gi,
+  /\bsk-[A-Za-z0-9_-]{8,}/g,
+  /\b[A-Za-z0-9_-]{32,}\b/g,
+]
+
+const PATH_PATTERNS = [
+  /(?:[A-Za-z]:\\|\/)(?:[^\s"'`]+[\\/])+[^\s"'`]*/g,
+  /~\/[^\s"'`]+/g,
+]
+
+export function sanitizeMessage(value) {
+  let text = typeof value === 'string' ? value : String(value ?? '')
+  // eslint-disable-next-line no-control-regex
+  text = text.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, '')
+  text = text.replace(/\r\n?/g, '\n')
+  for (const pattern of TOKEN_PATTERNS) text = text.replace(pattern, '[redacted]')
+  for (const pattern of PATH_PATTERNS) text = text.replace(pattern, '[path]')
+  const trimmed = text.trim()
+  return trimmed.length > 500 ? `${trimmed.slice(0, 497)}...` : trimmed
+}