threadwire 0.1.8 → 0.1.9

package/src/providers/kimi.js

@@ -0,0 +1,165 @@
+// @ts-check
+
+const EXECUTABLE = "/usr/local/bin/kimi"
+const ALIAS_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/u
+const SESSION_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,511}$/u
+const TOOL_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/u
+const TOOL_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_.:-]{0,127}$/u
+
+/** @typedef {import("../types.js").WorkerEvent} WorkerEvent */
+/** @typedef {{started: boolean, sessionEmitted: boolean, tools: Map<string, string>}} KimiRecordState */
+/** @typedef {{trusted: boolean, sessionId: string | undefined, events: WorkerEvent[]}} KimiRecognition */
+
+/** @param {string[]} providerArguments */
+export function validateKimiProviderArguments(providerArguments) {
+  if (providerArguments.length === 0) return {modelAlias: "default", arguments: []}
+  if (providerArguments.length === 2 && (providerArguments[0] === "--model" || providerArguments[0] === "-m")
+    && ALIAS_PATTERN.test(providerArguments[1] ?? "")) {
+    return {modelAlias: /** @type {string} */ (providerArguments[1]), arguments: ["--model", /** @type {string} */ (providerArguments[1])]}
+  }
+  throw new Error("Threadwire owns Kimi prompt, output, session, model configuration, permissions, and extensions")
+}
+
+/** @param {string[]} providerArguments @param {string} prompt @param {string | undefined} [resumeSession] */
+export function buildKimiCommand(providerArguments, prompt, resumeSession) {
+  const selection = validateKimiProviderArguments(providerArguments)
+  if (resumeSession !== undefined && !SESSION_PATTERN.test(resumeSession)) throw new Error("Kimi session ID is invalid")
+  return {
+    executable: EXECUTABLE,
+    arguments: [
+      "--model", selection.modelAlias,
+      ...(resumeSession === undefined ? [] : ["--session", resumeSession]),
+      "--prompt", prompt,
+      "--output-format", "stream-json"
+    ]
+  }
+}
+
+/** @returns {(record: unknown) => string | undefined} */
+export function createKimiSessionId() {
+  let emitted = false
+  return (record) => {
+    if (emitted) return undefined
+    const recognized = recognizeKimiRecord(record, undefined)
+    if (recognized.sessionId === undefined) return undefined
+    emitted = true
+    return recognized.sessionId
+  }
+}
+
+/** @returns {(record: unknown) => import("../types.js").WorkerEvent[]} */
+export function createKimiParser() {
+  const state = createKimiRecordState()
+  return (record) => recognizeKimiRecord(record, state).events
+}
+
+/** @param {unknown} record @returns {import("../types.js").WorkerEvent[]} */
+export function parseKimiEvent(record) {
+  return recognizeKimiRecord(record, createKimiRecordState()).events
+}
+
+/** @returns {KimiRecordState} */
+export function createKimiRecordState() {
+  return {started: false, sessionEmitted: false, tools: new Map()}
+}
+
+/** @param {unknown} record */
+export function kimiSessionEnvelopeId(record) {
+  return isRecord(record) && exactKeys(record, ["type", "sessionId"])
+    && record.type === "session" && typeof record.sessionId === "string" && SESSION_PATTERN.test(record.sessionId)
+    ? record.sessionId
+    : undefined
+}
+
+/**
+ * Convert one pinned Kimi stream-json record into the only envelopes the
+ * isolated worker may expose. Raw arguments, results, metadata, and stderr are
+ * never represented in the return value.
+ * @param {unknown} record
+ * @param {ReturnType<typeof createKimiRecordState>} state
+ */
+export function sanitizeKimiRecord(record, state) {
+  const recognized = recognizeKimiRecord(record, state)
+  /** @type {({type: "worker-event", event: WorkerEvent} | {type: "session", sessionId: string})[]} */
+  const output = recognized.events.map((event) => ({type: /** @type {const} */ ("worker-event"), event}))
+  if (recognized.sessionId !== undefined && !state.sessionEmitted) {
+    state.sessionEmitted = true
+    output.push({type: "session", sessionId: recognized.sessionId})
+  }
+  return output
+}
+
+/** @param {unknown} record @param {KimiRecordState | undefined} state @returns {KimiRecognition} */
+function recognizeKimiRecord(record, state) {
+  if (!isRecord(record)) return emptyRecognition()
+  if (record.role === "assistant" && exactOptionalKeys(record, ["role"], ["content", "tool_calls"])) {
+    /** @type {WorkerEvent[]} */
+    const events = []
+    if (record.content !== undefined) {
+      if (typeof record.content !== "string") return emptyRecognition()
+      events.push({type: "text-delta", text: record.content, streamId: "kimi:assistant"})
+    }
+    if (record.tool_calls !== undefined) {
+      if (!Array.isArray(record.tool_calls)) return emptyRecognition()
+      for (const toolCall of record.tool_calls) {
+        const parsed = parseToolCall(toolCall)
+        if (parsed === undefined) return emptyRecognition()
+        state?.tools.set(parsed.id, parsed.name)
+        events.push({type: "tool", phase: "started", name: parsed.name, key: `tool:${parsed.id}`})
+      }
+    }
+    if (events.length === 0) return emptyRecognition()
+    return {trusted: true, sessionId: undefined, events: withStarted(events, state)}
+  }
+  if (record.role === "tool" && exactKeys(record, ["role", "tool_call_id", "content"])
+    && typeof record.tool_call_id === "string" && TOOL_ID_PATTERN.test(record.tool_call_id)
+    && typeof record.content === "string") {
+    const name = state?.tools.get(record.tool_call_id)
+    if (name === undefined || state === undefined) return emptyRecognition()
+    state.tools.delete(record.tool_call_id)
+    return {
+      trusted: true,
+      sessionId: undefined,
+      events: withStarted([{type: "tool", phase: "finished", name, key: `tool:${record.tool_call_id}`}], state)
+    }
+  }
+  if (record.role === "meta" && record.type === "session.resume_hint"
+    && exactKeys(record, ["role", "type", "session_id", "command", "content"])
+    && typeof record.session_id === "string" && SESSION_PATTERN.test(record.session_id)
+    && typeof record.command === "string" && typeof record.content === "string") {
+    return {trusted: true, sessionId: record.session_id, events: withStarted([], state)}
+  }
+  return emptyRecognition()
+}
+
+/** @param {unknown} value @returns {{id: string, name: string} | undefined} */
+function parseToolCall(value) {
+  if (!isRecord(value) || !exactKeys(value, ["type", "id", "function"])
+    || value.type !== "function" || typeof value.id !== "string" || !TOOL_ID_PATTERN.test(value.id)
+    || !isRecord(value.function) || !exactKeys(value.function, ["name", "arguments"])
+    || typeof value.function.name !== "string" || !TOOL_NAME_PATTERN.test(value.function.name)
+    || typeof value.function.arguments !== "string") return undefined
+  return {id: value.id, name: value.function.name}
+}
+
+/** @param {WorkerEvent[]} events @param {KimiRecordState | undefined} state @returns {WorkerEvent[]} */
+function withStarted(events, state) {
+  if (state === undefined || state.started) return events
+  state.started = true
+  return [{type: "lifecycle", phase: "started", summary: "Kimi worker started"}, ...events]
+}
+/** @returns {KimiRecognition} */
+function emptyRecognition() { return {trusted: false, sessionId: undefined, events: []} }
+/** @param {unknown} value @returns {value is Record<string, unknown>} */
+function isRecord(value) { return typeof value === "object" && value !== null && !Array.isArray(value) }
+/** @param {Record<string, unknown>} value @param {readonly string[]} expected @returns {boolean} */
+function exactKeys(value, expected) {
+  const actual = Object.keys(value).sort()
+  const wanted = [...expected].sort()
+  return actual.length === wanted.length && actual.every((key, index) => key === wanted[index])
+}
+/** @param {Record<string, unknown>} value @param {readonly string[]} required @param {readonly string[]} optional @returns {boolean} */
+function exactOptionalKeys(value, required, optional) {
+  const actual = Object.keys(value)
+  return required.every((key) => actual.includes(key)) && actual.every((key) => required.includes(key) || optional.includes(key))
+}

package/src/telegram-ingress/command.js

@@ -2,16 +2,16 @@
 
 import {PROVIDERS} from "../providers/index.js"
 
-const COMMAND_PATTERN = /^\/code(?:@[A-Za-z0-9_]+)?\s+(codex|claude|opencode)\s+(\S[\s\S]*)$/u
+const COMMAND_PATTERN = /^\/code(?:@[A-Za-z0-9_]+)?\s+(codex|claude|kimi|opencode)\s+(\S[\s\S]*)$/u
 const EVIDENCE_PATTERN = /^\/evidence(?:@[A-Za-z0-9_]+)?\s+(evidence_[A-Za-z0-9_-]{43})\s+(bytes|lines)\s+(\d+):(\d+)$/u
 
 /**
- * @typedef {{provider: "codex" | "claude" | "opencode", prompt: string}} CodeCommand
+ * @typedef {{provider: "codex" | "claude" | "kimi" | "opencode", prompt: string}} CodeCommand
  */
 
 /**
  * Parse the exact ingress command grammar:
- * `/code[optional @bot] <codex|claude|opencode> <nonblank prompt>`
+ * `/code[optional @bot] <codex|claude|kimi|opencode> <nonblank prompt>`
  * @param {string} text
  * @returns {CodeCommand | null}
  */
@@ -24,7 +24,7 @@ export function parseCodeCommand(text) {
   if (prompt.length === 0) return null
   if (!PROVIDERS.includes(/** @type {(typeof PROVIDERS)[number]} */ (providerName))) return null
   return {
-    provider: /** @type {"codex" | "claude" | "opencode"} */ (providerName),
+    provider: /** @type {"codex" | "claude" | "kimi" | "opencode"} */ (providerName),
     prompt
   }
 }

package/src/telegram-ingress/config.js

@@ -139,6 +139,7 @@ export async function resolveIngressEnvironment(source, operations = {}) {
  *   host: string,
  *   maxConcurrentWorkers: number,
  *   toolMessages: boolean,
+ *   requireCodexIsolation: boolean,
  *   telegramRequestTimeoutMs: number,
  *   updateIdCapacity: number,
  *   updateIdTtlMs: number
@@ -166,6 +167,9 @@ export function parseIngressConfig(environment) {
     DEFAULT_MAX_CONCURRENT_WORKERS
   )
   const toolMessages = parseStrictBoolean(environment.THREADWIRE_TOOL_MESSAGES, "THREADWIRE_TOOL_MESSAGES", false)
+  const requireCodexIsolation = parseStrictBoolean(
+    environment.THREADWIRE_REQUIRE_CODEX_ISOLATION, "THREADWIRE_REQUIRE_CODEX_ISOLATION", false
+  )
   const telegramRequestTimeoutMs = parseTelegramRequestTimeoutMs(environment)
   const updateIdCapacity = parsePositiveSafeInteger(
     environment.THREADWIRE_UPDATE_ID_CAPACITY,
@@ -187,6 +191,7 @@ export function parseIngressConfig(environment) {
     host,
     maxConcurrentWorkers,
     toolMessages,
+    requireCodexIsolation,
     telegramRequestTimeoutMs,
     updateIdCapacity,
     updateIdTtlMs,
@@ -234,9 +239,15 @@ export function buildProviderEnvironment(source) {
 /** @param {string} key */
 function isIngressSecretKey(key) {
   if (FILE_BACKED_SETTINGS.some((name) => key === `${name}_FILE`)) return true
+  if (key === "THREADWIRE_REQUIRE_CODEX_ISOLATION") return true
   if (
     key.startsWith("THREADWIRE_ISOLATED_RUNTIME_")
     || key.startsWith("THREADWIRE_MODEL_BROKER_")
+    || key.startsWith("THREADWIRE_KIMI_")
+    || key === "KIMI_MODEL_API_KEY"
+    || key === "KIMI_API_KEY"
+    || key === "MOONSHOT_API_KEY"
+    || key === "KIMI_CODE_HOME"
     || key === "THREADWIRE_RELAY_WORKER_IMAGE"
     || key === "THREADWIRE_ALLOWED_WORKTREE_ROOTS"
     || key === "THREADWIRE_WORKTREE_VOLUME"

package/src/telegram-ingress/core.js

@@ -6,6 +6,7 @@ import {NoticeQueue} from "../notice-queue.js"
 import {createFetchTransport} from "../notifiers/fetch-transport.js"
 import {createTelegramSender} from "../notifiers/telegram.js"
 import {createProvider} from "../providers/index.js"
+import {kimiSessionEnvelopeId} from "../providers/kimi.js"
 import {Relay} from "../relay.js"
 import {runWorker} from "../run-worker.js"
 import {WorkerControl} from "../worker-control.js"
@@ -15,7 +16,7 @@ import {parseCodeCommand, parseEvidenceCommand} from "./command.js"
 
 /**
  * @typedef {{platform: "telegram", chatId: string, threadId: number | null}} TelegramTarget
- * @typedef {{provider: "codex" | "claude" | "opencode", prompt: string, target: TelegramTarget, senderId: string} | {type: "evidence", request: unknown, target: TelegramTarget, senderId: string}} AcceptedJob
+ * @typedef {{provider: "codex" | "claude" | "kimi" | "opencode", prompt: string, target: TelegramTarget, senderId: string} | {type: "evidence", request: unknown, target: TelegramTarget, senderId: string}} AcceptedJob
  * @typedef {{
  *   createProvider?: typeof createProvider,
  *   createFetchTransport?: typeof createFetchTransport,
@@ -30,6 +31,7 @@ import {parseCodeCommand, parseEvidenceCommand} from "./command.js"
  *   activity?: Pick<import("../activity-log.js").ActivityLog, "recordWorkspace" | "recordStarted" | "recordSession" | "close">,
  *   evidenceStore?: import("../evidence-store.js").EvidenceStore,
  *   isolatedRuntimeClient?: Pick<import("../isolated-runtime-client.js").IsolatedRuntimeClient, "preflight" | "run">,
+ *   kimiIsolatedRuntimeClient?: Pick<import("../isolated-runtime-client.js").IsolatedRuntimeClient, "preflight" | "run">,
  *   onWorkerFailure?: (message: string) => void,
  *   onWorkerSettled?: () => void
  * }} IngressDependencies
@@ -88,12 +90,19 @@ export function interpretUpdate(update, config) {
  * spawn rejects (HTTP 500). Failure after spawn is observed via
  * onWorkerFailure without empty-swallowing the error.
  * @param {AcceptedJob} job
- * @param {{botToken: string, telegramRequestTimeoutMs?: number, toolMessages?: boolean}} config
+ * @param {{botToken: string, telegramRequestTimeoutMs?: number, toolMessages?: boolean, requireCodexIsolation?: boolean}} config
  * @param {IngressDependencies} [dependencies]
  * @returns {Promise<void>}
  */
 export async function dispatchWorker(job, config, dependencies = {}) {
   if ("type" in job) throw new Error("Worker dispatch requires a worker job")
+  if (job.provider === "kimi" && dependencies.kimiIsolatedRuntimeClient === undefined) {
+    throw new Error("Kimi isolated runtime is required")
+  }
+  if (job.provider === "codex" && config.requireCodexIsolation === true
+    && dependencies.isolatedRuntimeClient === undefined) {
+    throw new Error("Codex isolated runtime is required")
+  }
   const createProviderImpl = dependencies.createProvider ?? createProvider
   const createFetchTransportImpl = dependencies.createFetchTransport ?? createFetchTransport
   const createTelegramSenderImpl = dependencies.createTelegramSender ?? createTelegramSender
@@ -108,6 +117,18 @@ export async function dispatchWorker(job, config, dependencies = {}) {
     {provider: job.provider},
     dependencies.workspaceProfileOperations
   )
+  const isolatedRuntimeClient = job.provider === "kimi"
+    ? dependencies.kimiIsolatedRuntimeClient
+    : job.provider === "codex" ? dependencies.isolatedRuntimeClient : undefined
+  const earlyKimiPreflight = job.provider === "kimi"
+    ? await /** @type {NonNullable<typeof isolatedRuntimeClient>} */ (isolatedRuntimeClient).preflight({
+      provider: "kimi",
+      profile: workspace.profile,
+      repositoryRoot: workspace.repositoryRoot,
+      cwd: workspace.cwd,
+      providerArguments: []
+    })
+    : undefined
 
   const provider = createProviderImpl(job.provider, [], job.prompt, undefined, providerEnvironment)
   dependencies.activity?.recordWorkspace(
@@ -137,30 +158,32 @@ export async function dispatchWorker(job, config, dependencies = {}) {
   try {
     await evidence?.append("prompt", `prompt\n${job.prompt}\nprovider-stream\n`)
 
-    if (job.provider === "codex" && dependencies.isolatedRuntimeClient !== undefined) {
+    if (isolatedRuntimeClient !== undefined) {
       evidenceTransferred = true
       try {
-        const preflight = await dependencies.isolatedRuntimeClient.preflight({
-          provider: "codex",
+        const preflight = earlyKimiPreflight ?? await isolatedRuntimeClient.preflight({
+          provider: job.provider,
           profile: workspace.profile,
           repositoryRoot: workspace.repositoryRoot,
           cwd: workspace.cwd,
           providerArguments: []
         })
-        const exitCode = await dependencies.isolatedRuntimeClient.run({
+        const exitCode = await isolatedRuntimeClient.run({
           preflightId: preflight.preflightId,
           prompt: job.prompt,
           providerArguments: [],
           ...(preflight.deadline === undefined ? {} : {deadline: preflight.deadline}),
           onEvent: async (event) => control.accept(event),
           onRecord: async (record) => {
-            const id = provider.sessionId(record)
+            const id = job.provider === "kimi" ? kimiSessionEnvelopeId(record) : provider.sessionId(record)
             if (id !== undefined) dependencies.activity?.recordSession(provider.name, id)
           },
-          onStdoutChunk: (chunk) => evidence?.append("provider-stdout", chunk),
-          onStderrChunk: (chunk) => evidence?.append("provider-stderr", chunk)
+          ...(job.provider === "kimi" ? {} : {
+            onStdoutChunk: (chunk) => evidence?.append("provider-stdout", chunk),
+            onStderrChunk: (chunk) => evidence?.append("provider-stderr", chunk)
+          })
         })
-        if (exitCode !== 0) throw new Error(`Isolated Codex worker exited with status ${exitCode}`)
+        if (exitCode !== 0) throw new Error(`Isolated ${job.provider === "kimi" ? "Kimi" : "Codex"} worker exited with status ${exitCode}`)
         await control.close()
         if (evidence !== undefined) {
           await evidence.finalize()

package/src/telegram-ingress/http.js

@@ -145,7 +145,8 @@ async function handleRequest(request, response, config, dependencies) {
       await dispatchWorker(job, {
         botToken: config.botToken,
         telegramRequestTimeoutMs: config.telegramRequestTimeoutMs,
-        toolMessages: config.toolMessages
+        toolMessages: config.toolMessages,
+        requireCodexIsolation: config.requireCodexIsolation
       }, {
         ...dependencies,
         onWorkerSettled: () => {

package/src/telegram-webhook.js

@@ -5,7 +5,7 @@ import {ActivityLog} from "./activity-log.js"
 import {EvidenceStore} from "./evidence-store.js"
 import {buildProviderEnvironment, parseIngressConfig, resolveIngressEnvironment} from "./telegram-ingress/config.js"
 import {createWebhookHandler} from "./telegram-ingress/http.js"
-import {isolatedRuntimeClientFromEnvironment} from "./isolated-runtime-client.js"
+import {isolatedRuntimeClientFromEnvironment, kimiIsolatedRuntimeClientFromEnvironment} from "./isolated-runtime-client.js"
 
 /**
  * Start the standalone Threadwire Telegram webhook service.
@@ -35,10 +35,14 @@ export async function startTelegramWebhook(options = {}) {
   const providerEnvironment = buildProviderEnvironment(
     options.providerEnvironment ?? environment
   )
-  const isolatedConfigured = environment.THREADWIRE_ISOLATED_RUNTIME_URL !== undefined
-    || environment.THREADWIRE_ISOLATED_RUNTIME_CONTROL_TOKEN !== undefined
+  const isolatedConfigured = typeof environment.THREADWIRE_ISOLATED_RUNTIME_CONTROL_TOKEN === "string"
+    && environment.THREADWIRE_ISOLATED_RUNTIME_CONTROL_TOKEN.trim().length > 0
   const isolatedRuntimeClient = options.handlerDependencies?.isolatedRuntimeClient
     ?? (isolatedConfigured ? isolatedRuntimeClientFromEnvironment(environment) : undefined)
+  const kimiIsolatedConfigured = typeof environment.THREADWIRE_KIMI_ISOLATED_RUNTIME_CONTROL_TOKEN === "string"
+    && environment.THREADWIRE_KIMI_ISOLATED_RUNTIME_CONTROL_TOKEN.trim().length > 0
+  const kimiIsolatedRuntimeClient = options.handlerDependencies?.kimiIsolatedRuntimeClient
+    ?? (kimiIsolatedConfigured ? kimiIsolatedRuntimeClientFromEnvironment(environment) : undefined)
   const activity = options.activity ?? options.handlerDependencies?.activity ?? new ActivityLog("/var/lib/threadwire/activity/threadwire.jsonl")
   const evidenceStore = options.evidenceStore ?? options.handlerDependencies?.evidenceStore ?? await EvidenceStore.open({
     root: config.evidenceRoot ?? "/var/lib/threadwire/evidence"
@@ -50,6 +54,7 @@ export async function startTelegramWebhook(options = {}) {
     evidenceStore,
     providerEnvironment,
     ...(isolatedRuntimeClient === undefined ? {} : {isolatedRuntimeClient}),
+    ...(kimiIsolatedRuntimeClient === undefined ? {} : {kimiIsolatedRuntimeClient}),
     onOperationalError,
     onWorkerFailure
   })

package/src/workspace-profile.js

@@ -14,7 +14,7 @@ const SOURCE_IDENTITY_PATTERN = /^[0-9a-f]{40}$|^[0-9a-f]{64}$/u
 const PROFILE_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u
 
 /**
- * @typedef {{repositoryRoot: string, cwd: string, providers: ("codex" | "claude" | "opencode")[]}} WorkspaceProfile
+ * @typedef {{repositoryRoot: string, cwd: string, providers: ("codex" | "claude" | "kimi" | "opencode")[]}} WorkspaceProfile
  * @typedef {{version: 1, defaultProfile: string, profiles: Record<string, WorkspaceProfile>}} WorkspaceProfilesConfig
  * @typedef {{profile: string, repositoryRoot: string, cwd: string, revision: string, sourceIdentity: string}} ResolvedWorkspaceProfile
  * @typedef {{repositoryRoot: string, revision: string, sourceIdentity: string}} GitProvenance
@@ -52,7 +52,7 @@ export function parseWorkspaceProfiles(value) {
 
 /**
  * Resolve a reviewed workspace profile to a validated in-container workspace.
- * @param {{provider: "codex" | "claude" | "opencode", profile?: string}} selection
+ * @param {{provider: "codex" | "claude" | "kimi" | "opencode", profile?: string}} selection
  * @param {WorkspaceProfileOperations} [operations]
  * @returns {Promise<ResolvedWorkspaceProfile>}
  */
@@ -137,7 +137,7 @@ async function readSourceIdentity(repositoryRoot, cwd) {
 /** @param {unknown} value */
 function parseProviders(value) {
   if (!Array.isArray(value) || value.length === 0) throw new Error("Workspace profile configuration is invalid")
-  /** @type {("codex" | "claude" | "opencode")[]} */
+  /** @type {("codex" | "claude" | "kimi" | "opencode")[]} */
   const providers = []
   for (const entry of value) {
     if (typeof entry !== "string") {

package/threadwire.workspace-profiles.json

@@ -5,7 +5,7 @@
     "container-runtime": {
       "repositoryRoot": "/workspace/threadwire",
       "cwd": "/workspace/threadwire",
-      "providers": ["codex"]
+      "providers": ["codex", "kimi"]
     }
   }
 }