omo-ai 5.1.38 → 5.1.41

package/bin/lib/launcher.js

@@ -12,6 +12,7 @@ import { isHostStatusAll, runHostStatusAll, sessionActivityReader } from "./host
 import { runDoctor } from "./doctor.js"
 import { ensureEnginePrepared, preparePluginLaunchSpec } from "./engine-prepare.js"
 import { migrateLegacyBunGlobalManifest } from "./legacy-bun-global-migration.js"
+import { removeLegacyServiceCredentials } from "./legacy-service-credentials.js"
 import { adoptLegacyFlatState, canonicalAgentDir } from "./agent-dir.js"
 import { senpiEnvironment } from "./engine-environment.js"
 import { withHerdrAgentHint } from "./herdr-agent-hint.js"
@@ -130,6 +131,7 @@ export function rollbackMigrateCall(request) {
 
 export async function runLauncher(args = process.argv.slice(2)) {
   migrateLegacyBunGlobalManifest()
+  removeLegacyServiceCredentials()
   reportLegacyFlatAdoption()
   const command = args[0]
   // The toolkit CLI is no longer part of the Native payload; the loop is driven in-process by the

package/bin/lib/legacy-service-credentials.js

@@ -0,0 +1,36 @@
+import { lstatSync, readFileSync, unlinkSync } from "node:fs"
+import { homedir } from "node:os"
+import { join } from "node:path"
+
+// An intermediate sign-in build left device private keys and refresh material in a plaintext
+// `~/.omo/credentials.json`, sometimes world-readable (#10697). Credentials now live only in the OS
+// keystore, so nothing reads this file; remove it on launch. Only the exact legacy shape is removed:
+// a regular file (never a symlink or FIFO) whose JSON object carries both private keys.
+const MAX_LEGACY_BYTES = 64 * 1024
+
+export function removeLegacyServiceCredentials(home = process.env.HOME || process.env.USERPROFILE || homedir()) {
+  const path = join(home, ".omo", "credentials.json")
+  let stats
+  try {
+    stats = lstatSync(path)
+  } catch {
+    return false
+  }
+  if (!stats.isFile() || stats.size > MAX_LEGACY_BYTES) return false
+
+  let parsed
+  try {
+    parsed = JSON.parse(readFileSync(path, "utf8"))
+  } catch {
+    return false
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return false
+  if (!("signingPrivateKey" in parsed) || !("sealingPrivateKey" in parsed)) return false
+
+  try {
+    unlinkSync(path)
+  } catch {
+    return false
+  }
+  return true
+}

package/bin/lib/provider-map.json

@@ -1,5 +1,5 @@
 {
-  "_comment": "Derived from @code-yeongyu/senpi 2026.10.19 builtinProviders(). builtinProviderIds and oauthProviderIds are the engine registry verbatim; providers maps a source harness id onto the omo provider that serves the same endpoint; oauthLogins maps a source OAuth id onto the omo provider to run /login for. Re-derive all four whenever the senpi pin changes.",
+  "_comment": "Derived from @code-yeongyu/senpi 2026.10.21-1 builtinProviders(). builtinProviderIds and oauthProviderIds are the engine registry verbatim; providers maps a source harness id onto the omo provider that serves the same endpoint; oauthLogins maps a source OAuth id onto the omo provider to run /login for. Re-derive all four whenever the senpi pin changes.",
   "builtinProviderIds": [
     "alibaba-token-plan",
     "amazon-bedrock",

package/bin/lib/setup-credentials.js

@@ -165,7 +165,13 @@ export async function planCredentials(runtime, target, customProviderIds) {
   }
 }
 
-export function applyCredentials(plan) {
+/**
+ * The stage's one writer. With `options.writeAuth` (the engine's locked credential store) the
+ * additions merge into whatever the store holds under its lock; the CLI path keeps its direct
+ * backup-and-write.
+ */
+export function applyCredentials(plan, options = {}) {
+  if (options.writeAuth !== undefined) return options.writeAuth(plan.target, plan.result.additions)
   writeAuthStore(plan.target, plan.current, plan.result.additions)
 }
 

package/bin/lib/setup-import.js

@@ -1,20 +1,16 @@
 /**
- * `omo setup`: every stage's plan is built first (nothing is written while planning), the one
- * summary renders them all, one consent covers the whole plan, then each stage applies its part.
- * `--ask-each` asks per stage instead; `--yes` consents; `--dry-run` prints the summary and exits.
+ * `omo setup`: every stage's plan is built first from the setup stream (nothing is written while
+ * planning), the one summary renders them all, one consent covers the whole plan, then each stage
+ * applies its part. `--ask-each` asks per stage instead; `--yes` consents; `--dry-run` prints the
+ * summary and exits.
  */
 
 import { homedir } from "node:os"
-import { dirname, join, relative } from "node:path"
+import { dirname, relative } from "node:path"
 import { createInterface } from "node:readline/promises"
 import { canonicalAgentDir } from "./agent-dir.js"
 import { setupCoverage } from "./category-coverage.js"
-import { detectHarnesses } from "./setup-detect.js"
-import { applyCredentials, credentialCounts, credentialPlanLines, credentialQuestion, opencodeOauthProviders, planCredentials } from "./setup-credentials.js"
-import { applyAssets, assetCounts, assetPlanLines, assetQuestion, planAssets } from "./setup-assets-import.js"
-import { planOpencodeProviders } from "./setup-opencode-providers.js"
-import { applyProviders, planProviders, providerCounts, providerPlanLines, providerQuestion } from "./setup-providers-import.js"
-import { applyModelChoices, modelChoiceCounts, modelChoicePlanLines, modelChoiceQuestion, planModelChoices } from "./setup-model-choices-import.js"
+import { applySetupStages, collectSetupPlans, scanSetup, setupStages } from "./setup-stream.js"
 import { displayPath, formatSetupSummary, TELEMETRY_NOTICE } from "./setup-summary.js"
 
 function write(lines) {
@@ -37,17 +33,6 @@ async function ask(question, options, defaultYes) {
   }
 }
 
-// In apply order: the model-choice stage runs last because a default model or category may name a
-// custom provider the stage before it carries. `present` stages report counts after the run.
-function stageList(plans) {
-  return [
-    { plan: plans.credentials, present: !plans.credentials.malformed, lines: credentialPlanLines, counts: credentialCounts, question: credentialQuestion, apply: applyCredentials },
-    { plan: plans.assets, present: plans.assets.present, lines: assetPlanLines, counts: assetCounts, question: assetQuestion, apply: applyAssets },
-    { plan: plans.providers, present: plans.providers.present, lines: providerPlanLines, counts: providerCounts, question: providerQuestion, apply: applyProviders },
-    { plan: plans.modelChoices, present: plans.modelChoices.present, lines: modelChoicePlanLines, counts: modelChoiceCounts, question: modelChoiceQuestion, apply: applyModelChoices },
-  ]
-}
-
 // The directories the whole plan writes into, a directory inside another one folded into it.
 function targetRoots(plans, agentDir, home) {
   const choiceDirs = plans.modelChoices.items.filter((item) => item.state === "pending").map((item) => dirname(item.target.path))
@@ -56,51 +41,20 @@ function targetRoots(plans, agentDir, home) {
   return roots.filter((path) => !roots.some((root) => inside(path, root))).map((path) => displayPath(path, home))
 }
 
-async function planAll(runtime, agentDir) {
-  const providerSource = planOpencodeProviders(runtime)
-  // A provider the custom-provider stage described (carried or refused with its reason) is reported there only.
-  const described = new Set([...providerSource.providers.map((item) => item.id), ...providerSource.skipped])
-  const credentials = await planCredentials(runtime, join(agentDir, "auth.json"), described)
-  const assets = planAssets({ runtime, agentDir })
-  const providers = planProviders(providerSource, agentDir)
-  const oauthProviders = opencodeOauthProviders(runtime)
-  const planChoices = (customProviders) => planModelChoices({ runtime, agentDir, customProviders, oauthProviders })
-  return { credentials, assets, providers, modelChoices: await planChoices(providers.result.added), planChoices }
-}
-
-// Per-stage consent. A declined provider stage leaves models.json as it is, so the model choices
-// are re-planned against it rather than against providers that will not exist.
-async function applyEach(plans, confirm) {
-  const applied = new Set()
-  for (const [index, stage] of stageList(plans).entries()) {
-    if (index === 3 && plans.providers.pending > 0 && !applied.has(2)) {
-      const shown = new Set(plans.modelChoices.notices)
-      plans.modelChoices = await plans.planChoices([])
-      stage.plan = plans.modelChoices
-      write(plans.modelChoices.notices.filter((notice) => !shown.has(notice)))
-    }
-    if (stage.plan.pending === 0) continue
-    if (!await confirm(stage.question(stage.plan), false)) continue
-    stage.apply(stage.plan)
-    applied.add(index)
-  }
-  return applied
-}
-
 export async function runSetup(args = process.argv.slice(2), options = {}) {
   const home = options.home ?? homedir()
   const env = options.env ?? process.env
   const agentDir = canonicalAgentDir(env, home)
   const runtime = { stdin: process.stdin, stdout: process.stdout, ...options, home, env }
   const dryRun = args.includes("--dry-run")
-  const inventory = await detectHarnesses(runtime)
-  const plans = await planAll(runtime, agentDir)
+  // The CLI has always carried OpenCode's custom providers; the onboarding RPC leaves them opt-in.
+  const { inventory, plans } = await collectSetupPlans(scanSetup(runtime, agentDir, { includeCustomProviders: true }))
   if (dryRun) process.stdout.write("DRY RUN: no files will be written\n")
   const categories = await setupCoverage({ agentDir, home, env, plans, loadRuntime: options.loadCoverageRuntime, loadEngine: options.loadCoverageEngine })
   process.stdout.write(formatSetupSummary({ home, agentDir, inventory, ...plans, categories }))
   process.stdout.write(`${TELEMETRY_NOTICE}\n`)
   if (dryRun) {
-    write(stageList(plans).filter((stage) => stage.present).flatMap((stage) => stage.lines(stage.plan)))
+    write(setupStages(plans).filter((stage) => stage.present).flatMap((stage) => stage.lines(stage.plan)))
     return
   }
   const confirm = async (question, defaultYes) => {
@@ -108,19 +62,15 @@ export async function runSetup(args = process.argv.slice(2), options = {}) {
     if (!accepted && runtime.stdin.isTTY === true) process.stdout.write("Import cancelled\n")
     return accepted
   }
-  const pending = stageList(plans).reduce((total, stage) => total + stage.plan.pending, 0)
+  const pending = setupStages(plans).reduce((total, stage) => total + stage.plan.pending, 0)
   let applied = new Set()
   if (pending === 0) {
     process.stdout.write("Nothing new to import.\n")
   } else if (args.includes("--ask-each")) {
-    applied = await applyEach(plans, confirm)
+    applied = await applySetupStages(plans, (stage) => confirm(stage.question(stage.plan), false), (line) => write([line]))
   } else {
     if (!await confirm(`Import all of the above into ${targetRoots(plans, agentDir, home).join(" and ")}? [Y/n] `, true)) return
-    for (const [index, stage] of stageList(plans).entries()) {
-      if (stage.plan.pending === 0) continue
-      stage.apply(stage.plan)
-      applied.add(index)
-    }
+    applied = await applySetupStages(plans, () => true, (line) => write([line]))
   }
-  write(stageList(plans).filter((stage, index) => stage.present && (applied.has(index) || stage.plan.pending === 0)).flatMap((stage) => stage.counts(stage.plan)))
+  write(setupStages(plans).filter((stage) => stage.present && (applied.has(stage.id) || stage.plan.pending === 0)).flatMap((stage) => stage.counts(stage.plan)))
 }

package/bin/lib/setup-model-choices-import.js

@@ -151,7 +151,7 @@ function writeText(target, text) {
 
 // Every edit is an insertion into the file's own text (comments, order and formatting survive);
 // a file the edit cannot reproduce exactly is left untouched and reported.
-function writeTarget(target, items) {
+function writeTarget(target, items, report) {
   try {
     let text = target.text ?? "{}\n"
     for (const item of items) {
@@ -160,7 +160,7 @@ function writeTarget(target, items) {
     writeText(target, text)
     return items.map((item) => item.label)
   } catch (error) {
-    process.stdout.write(`WARN senpi: could not edit ${target.path} safely (${error.message}); these model choices were not written: ${items.map((item) => item.label).join(", ")}\n`)
+    report(`WARN senpi: could not edit ${target.path} safely (${error.message}); these model choices were not written: ${items.map((item) => item.label).join(", ")}`)
     return []
   }
 }
@@ -198,9 +198,12 @@ export async function planModelChoices(stage) {
   }
 }
 
-/** The stage's one writer; records what it wrote as `plan.carried` for the counts. */
-export function applyModelChoices(plan) {
+/** The stage's one writer; records what it wrote as `plan.carried` for the counts. `options.report`
+ * receives the warning when a target cannot be edited (the CLI prints it; callers inside the
+ * engine route it to their own reply). */
+export function applyModelChoices(plan, options = {}) {
+  const report = options.report ?? ((line) => process.stdout.write(`${line}\n`))
   const pending = plan.items.filter((item) => item.state === "pending")
   const targets = [...new Set(pending.map((item) => item.target))]
-  plan.carried = targets.flatMap((target) => writeTarget(target, pending.filter((item) => item.target === target)))
+  plan.carried = targets.flatMap((target) => writeTarget(target, pending.filter((item) => item.target === target), report))
 }

package/bin/lib/setup-providers-import.js

@@ -101,18 +101,25 @@ function writeModels(path, target, added) {
 export function planProviders(source, agentDir) {
   const paths = { models: join(agentDir, "models.json"), auth: join(agentDir, "auth.json") }
   const models = readModelsTarget(paths.models)
-  const result = classify(source, models, readAuthStore(paths.auth))
+  const auth = readAuthStore(paths.auth)
+  const result = classify(source, models, auth)
   const notices = [...source.notices]
   if (result.blocked.length > 0) notices.push(`WARN senpi: malformed models.json; these custom providers were not imported: ${result.blocked.join(", ")}`)
-  return { paths, models, notices, result, skipped: source.skipped, present: source.providers.length > 0, pending: result.added.length }
+  return { paths, models, authBytes: auth.bytes, notices, result, skipped: source.skipped, present: source.providers.length > 0, pending: result.added.length }
 }
 
-export function applyProviders(plan) {
+/**
+ * The stage's one writer. With `options.writeAuth` the provider keys merge into whatever the
+ * store holds under its lock; the CLI path keeps its direct backup-and-write.
+ */
+export function applyProviders(plan, options = {}) {
   writeModels(plan.paths.models, plan.models, plan.result.added)
   // Re-read: the credential stage of the same run may have just written auth.json, after this plan
   // was classified. A mapped credential target can also be a custom provider id (claude-sdk-oauth ->
   // anthropic-subscription), so a key written since the plan is kept, never overwritten.
   const auth = readAuthStore(plan.paths.auth)
   plan.result.keys = auth.malformed ? [] : plan.result.keys.filter((item) => !Object.hasOwn(auth.entries, item.provider))
-  if (plan.result.keys.length > 0) writeAuthStore(plan.paths.auth, auth, plan.result.keys)
+  if (plan.result.keys.length === 0) return
+  if (options.writeAuth !== undefined) return options.writeAuth(plan.paths.auth, plan.result.keys)
+  writeAuthStore(plan.paths.auth, auth, plan.result.keys)
 }

package/bin/lib/setup-stream-items.js

@@ -0,0 +1,64 @@
+/**
+ * One `{id, kind, state, detail?}` row per thing a setup source found, built from the stage plan
+ * the summary renders. Rows travel over RPC, so they carry ids and states only: never a key.
+ */
+
+const MODEL_CHOICE_STATES = { pending: "import", kept: "exists", carried: "carried", blocked: "blocked" }
+
+function rows(ids, kind, state) {
+  return ids.map((id) => ({ id, kind, state }))
+}
+
+function detectItems(inventory) {
+  return inventory.harnesses
+    .filter((harness) => harness.installed)
+    .map((harness) => ({ id: harness.id, kind: "harness", state: "found", detail: `${harness.entryCount} login(s), ${harness.importableCount} importable` }))
+}
+
+function providerItems(plan) {
+  const { result } = plan
+  return [
+    ...result.added.map((provider) => ({ id: provider.id, kind: "provider", state: "import", detail: `${provider.config.models.length} model(s)` })),
+    ...rows(result.skippedExisting, "provider", "exists"),
+    ...rows(result.blocked, "provider", "blocked"),
+    ...rows(plan.skipped, "provider", "skipped"),
+  ]
+}
+
+function credentialItems(plan) {
+  if (plan.malformed) return []
+  const { result, guidance } = plan
+  return [
+    ...result.additions.map((item) => ({ id: item.provider, kind: "api-key", state: "import", detail: `from ${item.source}` })),
+    ...rows(result.skippedExisting, "api-key", "exists"),
+    ...guidance.logins.map((login) => ({ id: login.provider, kind: "oauth", state: login.state, ...(login.target === undefined ? {} : { detail: `/login ${login.target}` }) })),
+    ...rows(result.skippedUnmapped, "api-key", "unmapped"),
+  ]
+}
+
+function assetItems({ result }) {
+  return [
+    ...result.servers.added.map((server) => ({ id: server.name, kind: "mcp", state: "import" })),
+    ...rows(result.servers.skippedExisting, "mcp", "exists"),
+    ...rows(result.servers.blocked, "mcp", "blocked"),
+    ...result.skills.added.map((skill) => ({ id: skill.name, kind: "skill", state: "import" })),
+    ...rows(result.skills.skippedExisting, "skill", "exists"),
+    ...rows(result.skills.skippedBundled, "skill", "bundled"),
+  ]
+}
+
+function modelChoiceItems(plan) {
+  return plan.items.map((item) => ({ id: item.label, kind: item.kind, state: MODEL_CHOICE_STATES[item.state] ?? item.state }))
+}
+
+const ITEMS_BY_SOURCE = {
+  detect: detectItems,
+  providers: providerItems,
+  credentials: credentialItems,
+  assets: assetItems,
+  "model-choices": modelChoiceItems,
+}
+
+export function setupStageItems(source, plan) {
+  return ITEMS_BY_SOURCE[source](plan)
+}

package/bin/lib/setup-stream.d.ts

@@ -0,0 +1,94 @@
+// Types for setup-stream.js, which omo-senpi's onboarding scan imports across the package
+// boundary: omo-ai ships this module as plain JS, so it is the single source of the setup stream.
+
+export type SetupSource = "detect" | "providers" | "credentials" | "assets" | "model-choices"
+export type SetupStageId = "credentials" | "assets" | "providers" | "model-choices"
+
+export const SETUP_SOURCES: readonly SetupSource[]
+
+export type SetupItem = {
+  readonly id: string
+  readonly kind: string
+  readonly state: string
+  readonly detail?: string
+}
+
+export type SetupStagePlan = {
+  readonly pending: number
+  readonly notices?: readonly string[]
+  readonly [field: string]: unknown
+}
+
+export type SetupStageResult = {
+  readonly source: SetupSource
+  readonly items: readonly SetupItem[]
+  readonly notices: readonly string[]
+  readonly plan: SetupStagePlan
+  readonly disabled?: true
+  readonly error?: Error
+}
+
+export type SetupRuntime = {
+  readonly home: string
+  readonly env: Readonly<Record<string, string | undefined>>
+  readonly pluginRoot?: string
+  readonly loadModelCatalog?: () => Promise<readonly unknown[]>
+  readonly loadSqlite?: () => Promise<unknown>
+}
+
+export type SetupScanOptions = {
+  readonly includeCustomProviders?: boolean
+  readonly onSourceStart?: (source: SetupSource) => void
+}
+
+export type SetupInventory = {
+  readonly harnesses: readonly { readonly id: string; readonly installed: boolean }[]
+}
+
+export type SetupPlans = { readonly [stage: string]: unknown }
+
+export type SetupApplyStage = {
+  readonly id: SetupStageId
+  readonly plan: SetupStagePlan
+}
+
+export function canonicalAgentDir(env?: Readonly<Record<string, string | undefined>>, home?: string): string
+
+export function scanSetup(runtime: SetupRuntime, agentDir: string, options?: SetupScanOptions): AsyncGenerator<SetupStageResult, void, undefined>
+
+export function collectSetupPlans(stream: AsyncIterable<SetupStageResult> | Iterable<SetupStageResult>): Promise<{ inventory: SetupInventory; plans: SetupPlans }>
+
+export type SetupAuthEntry = {
+  readonly provider: string
+  readonly key: string
+}
+
+/** Per-apply writer options: how credential additions and notice lines travel. */
+export type SetupApplyOptions = {
+  /** Routes credential additions through a locked credential store (the engine's AuthStorage) instead of the CLI's direct writer. */
+  readonly writeAuth?: (target: string, additions: readonly SetupAuthEntry[]) => Promise<void> | void
+  /** Receives the apply's notice lines (the CLI prints them; an RPC caller collects them into its reply). */
+  readonly report?: (line: string) => void
+}
+
+/** Refused by `applySetupStages` when `staleGuard` finds a target that changed since planning. */
+export class SetupStaleError extends Error {
+  readonly paths: readonly string[]
+  readonly applied: readonly SetupStageId[]
+}
+
+/** The target paths of the given stages whose content changed since their plans read them (content hash, never mtime alone). */
+export function staleSetupTargets(plans: SetupPlans, stageIds: Iterable<SetupStageId>, written?: ReadonlySet<string>): string[]
+
+/** True when any of the given stages would write into a credential store. */
+export function authWritesPending(plans: SetupPlans, stageIds: Iterable<SetupStageId>): boolean
+
+export function applySetupStages(
+  plans: SetupPlans,
+  confirm: (stage: SetupApplyStage) => boolean | Promise<boolean>,
+  report?: (line: string) => void,
+  options?: SetupApplyOptions & {
+    /** Re-checked right before each stage writes; a non-empty result refuses that stage with `SetupStaleError`. */
+    readonly staleGuard?: (stageId: SetupStageId, written: ReadonlySet<string>) => readonly string[] | undefined
+  },
+): Promise<Set<SetupStageId>>