@kukonce/dsh-loomy 0.0.0-stage → 0.3.2

package/src/core/paths.js

@@ -0,0 +1,71 @@
+/**
+ * Where this plugin keeps everything it owns.
+ *
+ * One directory, `$DSH_HOME/dsh-loomy/`: the account list, the login session for
+ * each account, the model catalog cache and the daily-credit ledger. Keeping them
+ * together means "reset the plugin" is one folder to delete.
+ *
+ * Credentials are written here rather than through the harness credentials service
+ * for the same reason the WorkBuddy plugin does it: that service keeps one document
+ * for every plugin, and these tokens have no business sharing a file or a ref
+ * namespace with anything else.
+ */
+
+import { chmodSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+/** `$DSH_HOME`, falling back to `~/.dsh` the same way the harness does. */
+function dshHome() {
+  return typeof process.env.DSH_HOME === 'string' && process.env.DSH_HOME.length > 0
+    ? process.env.DSH_HOME
+    : join(homedir(), '.dsh')
+}
+
+/** The plugin's own directory, created owner-only on demand. */
+export function ensurePluginDir() {
+  const dir = join(dshHome(), 'dsh-loomy')
+  mkdirSync(dir, { recursive: true, mode: 0o700 })
+  return dir
+}
+
+/** Absolute path of a file inside the plugin directory. */
+export function pluginFile(name) {
+  return join(ensurePluginDir(), name)
+}
+
+/**
+ * Read a JSON file from the plugin directory, or `undefined` when it is missing or
+ * unreadable. A corrupt file reads as absent: a broken cache must never break a start.
+ */
+export function readJson(name) {
+  try {
+    return JSON.parse(readFileSync(pluginFile(name), 'utf8'))
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Write a JSON file atomically: staged inside the directory (a temp file on another
+ * volume makes `rename` fail with EXDEV), then renamed over the target.
+ */
+export function writeJson(name, value, options = {}) {
+  const target = pluginFile(name)
+  const staging = join(ensurePluginDir(), `.${name}.${process.pid}.tmp`)
+  writeFileSync(staging, JSON.stringify(value, null, options.pretty === true ? 2 : 0), { mode: 0o600 })
+  renameSync(staging, target)
+  if (options.mode !== undefined) chmodSync(target, options.mode)
+  return target
+}
+
+/** Delete a file from the plugin directory; a missing one is not an error. */
+export function removeJson(name) {
+  try {
+    const target = pluginFile(name)
+    readFileSync(target)
+    renameSync(target, join(ensurePluginDir(), `.${name}.deleted.${Date.now()}.tmp`))
+  } catch {
+    // absent is the desired state
+  }
+}

package/src/core/sign.js

@@ -0,0 +1,166 @@
+/**
+ * iFlytek CAccount request signing (HMAC-SHA1).
+ *
+ * The account service authenticates the *application* with a key pair and the
+ * *request* with a signature over a canonical string. Getting the canonical string
+ * exactly right is the whole problem: a single differing separator yields
+ * `010003 请求参数错误` with no hint about which part was wrong.
+ *
+ * The string is nine lines, joined with `\\n`:
+ *
+ *   METHOD
+ *   ESCAPED_PATH            (/login/phone/sendMsgCode)
+ *   ESCAPED_QUERY_STRING    (sorted? no — insertion order)
+ *   CONTENT_MD5             base64 MD5 of the body, '' when there is no body
+ *   CONTENT_TYPE            application/json
+ *   DATE                    HTTP-date (toUTCString)
+ *   NONCE                   uuid
+ *   SIGNED_HEADERS          comma/; joined `x-*` header names, '' when none
+ *   CANONICALIZED_HEADERS   `k:v\\n` per `x-*` header, '' when none
+ *
+ * Verified against the live endpoint: a signed `getPuKey` answers
+ * `{\"code\":\"000000\"}` with this implementation.
+ */
+
+import { createHash, createHmac, randomUUID } from 'node:crypto'
+
+/** base64 MD5 of the request body; empty string for a bodyless request. */
+export function contentMD5(body) {
+  if (!body) return ''
+  const text = typeof body === 'string' ? body : JSON.stringify(body)
+  return createHash('md5').update(text, 'utf8').digest('base64')
+}
+
+/** RFC3986 path/query escaping: everything encodeURIComponent leaves alone becomes %XX. */
+function escapeRFC3986(value) {
+  return encodeURIComponent(value)
+    .replace(/!/g, '%21')
+    .replace(/'/g, '%27')
+    .replace(/\(/g, '%28')
+    .replace(/\)/g, '%29')
+    .replace(/\*/g, '%2A')
+}
+
+function escapedPath(path) {
+  let clean = path.startsWith('/') ? path : `/${path}`
+  if (clean.length > 1 && clean.endsWith('/')) clean = clean.slice(0, -1)
+  return clean.split('/').map((segment) => (segment ? escapeRFC3986(segment) : '')).join('/')
+}
+
+function escapedQuery(queryParams) {
+  const entries = Object.entries(queryParams ?? {})
+  if (entries.length === 0) return ''
+  return entries
+    .map(([key, value]) => `${escapeRFC3986(key)}=${value === null || value === undefined ? '' : escapeRFC3986(String(value))}`)
+    .join('&')
+}
+
+/**
+ * Canonical headers, restricted to the `x-` prefix the protocol signs.
+ *
+ * The trailing newline on every line — including the last — is part of the format.
+ */
+function canonicalizedHeaders(headers) {
+  const selected = new Map()
+  for (const [key, value] of Object.entries(headers ?? {})) {
+    const lower = key.toLowerCase()
+    if (lower.startsWith('x-')) selected.set(lower, String(value).trim())
+  }
+  const keys = [...selected.keys()].sort()
+  if (keys.length === 0) return { canonical: '', signed: '' }
+  return {
+    canonical: keys.map((key) => `${key}:${selected.get(key)}\n`).join(''),
+    signed: keys.join(';')
+  }
+}
+
+/**
+ * Build the nine-line string that gets signed.
+ *
+ * Exported because it is the only way to debug a signature mismatch: print this and
+ * diff it against a known-good capture.
+ */
+export function buildStringToSign({
+  method,
+  path,
+  queryParams = {},
+  body = '',
+  contentType = 'application/json',
+  date,
+  nonce,
+  customHeaders = {}
+}) {
+  const { canonical, signed } = canonicalizedHeaders(customHeaders)
+  return [
+    String(method).toUpperCase(),
+    escapedPath(path),
+    escapedQuery(queryParams),
+    contentMD5(body),
+    contentType,
+    date,
+    nonce,
+    signed,
+    canonical.replace(/\n$/, '')
+  ].join('\n')
+}
+
+export function signRequest({
+  accessKeyId,
+  accessKeySecret,
+  method,
+  path,
+  queryParams = {},
+  body = '',
+  contentType = 'application/json',
+  date = new Date().toUTCString(),
+  nonce = randomUUID(),
+  customHeaders = {}
+}) {
+  const stringToSign = buildStringToSign({ method, path, queryParams, body, contentType, date, nonce, customHeaders })
+  const signature = createHmac('sha1', accessKeySecret).update(stringToSign, 'utf8').digest('base64')
+  return { signature, stringToSign }
+}
+
+/**
+ * Full header set for one CAccount request.
+ *
+ * `Authorization` carries the `account` scheme name, the key id and the signature;
+ * `Content-MD5` is only present when there is a body (a bodyless GET with an MD5 of
+ * the empty string is rejected).
+ */
+export function buildAccountHeaders({
+  accessKeyId,
+  accessKeySecret,
+  method,
+  path,
+  queryParams = {},
+  body = '',
+  contentType = 'application/json',
+  customHeaders = {}
+}) {
+  const date = new Date().toUTCString()
+  const nonce = randomUUID()
+  const { signature } = signRequest({
+    accessKeyId,
+    accessKeySecret,
+    method,
+    path,
+    queryParams,
+    body,
+    contentType,
+    date,
+    nonce,
+    customHeaders
+  })
+  const md5 = contentMD5(body)
+  const headers = {
+    Authorization: `account ${accessKeyId}:${signature}`,
+    Date: date,
+    Nonce: nonce,
+    'Content-Type': contentType,
+    'User-Agent': 'Loomy-Desktop-DSH',
+    ...customHeaders
+  }
+  if (md5.length > 0) headers['Content-MD5'] = md5
+  return headers
+}

package/src/index.js

@@ -0,0 +1,429 @@
+/**
+ * dsh-loomy -- Loomy (讯飞 Loomy) accounts as DeepSeek Harness model providers.
+ *
+ * Loomy has no API keys. An account signs in to iFlytek's CAccount service — by SMS
+ * code, or by adopting the login the Loomy desktop app already has — and the `session`
+ * string that comes back is the credential for both the points API and the model
+ * gateway. So this plugin's job splits cleanly in two:
+ *
+ *   accounts/   log in, keep the session, claim the daily credit, read the catalog
+ *   llm/        turn that account into one OpenAI-compatible provider route
+ *
+ * One provider route per account, never one shared route: the catalog and the balance are
+ * both scoped to the account, and the picker groups by provider — two accounts on one
+ * route would present as one account whose model list keeps changing.
+ *
+ * The daily credit is the reason the timers below exist. Loomy grants 5000 "每日赠送"
+ * points per day, renewed by `POST /api/v1/points/first-login` — a call whose name says
+ * "first login" but whose behaviour is "claim today's quota, idempotently". Without it
+ * the balance stays at whatever yesterday left, so it is claimed once shortly after start
+ * and again at every local midnight.
+ */
+
+import { randomUUID } from 'node:crypto'
+
+import { readAccounts, accountOf, assertAccountId, importDesktopAccount, loginBySmsCode, logoutRemote, removeAccount, renameAccount, sendSmsCode } from './account/auth.js'
+import { anchorLedger, ensureDailyGrant, fetchCredits, fetchOnboardingTasks, completeOnboardingTask, grantedToday } from './account/credits.js'
+import { loadCatalog, readCachedCatalog } from './account/models.js'
+import { accountsWithState, expiredInfo, isExpired, markExpired, sessionForId } from './account/session.js'
+import { GATEWAY_BASE_URL } from './core/endpoints.js'
+import { formatWhen, msUntilNextMidnight } from './core/http.js'
+import { LoomyAdapter } from './llm/adapter.js'
+import { registerLoomyApi } from './panel/api.js'
+
+export const name = 'dsh-loomy'
+export const inject = ['commands', 'llm']
+
+/** The daily-credit claim runs a little after the rest of the plugin has settled. */
+const GRANT_BOOT_DELAY_MS = 12_000
+
+/**
+ * The in-flight SMS login: `{ phone, msgid, expiresAt }`.
+ *
+ * Kept in memory rather than on disk. An SMS code lives five minutes, and persisting a
+ * half-finished login would leave a stale `msgid` for the next attempt to trip over —
+ * a failure that reads as "the code was wrong" when it was really yesterday's code.
+ */
+let pendingLogin
+
+/**
+ * The provider route for one account.
+ *
+ * Kept in one place because three things depend on the exact spelling: registration,
+ * the model picker's persisted selection, and the `/loomy` command's output.
+ */
+export function providerFor(accountId) {
+  return `@loomy/dsh-loomy/${accountId}`
+}
+
+/**
+ * Claim today's 5000 on every account that has not had it yet today.
+ *
+ * Serial rather than parallel on purpose: these are the same endpoint for different
+ * sessions, and a burst of claims is the one pattern a rate limiter would notice. The
+ * cost of serial is one HTTP round trip per account once a day.
+ */
+async function runDailyGrant(ctx, reason) {
+  const outcomes = []
+  for (const account of readAccounts()) {
+    if (grantedToday(account.id)) {
+      outcomes.push({ id: account.id, skipped: true });
+      continue;
+    }
+    try {
+      const result = await ensureDailyGrant(account.id, account.session, { reason })
+      if (result.granted === true) {
+        ctx.logger.info(`[loomy] ${account.id}: 每日赠送积分已刷新（${result.balance ?? 0}/${result.quota ?? 0}，${reason}）`)
+      } else if (result.isAuthError === true) {
+        markExpired(account.id, '领取每日积分时登录失效')
+        ctx.logger.warn(`[loomy] ${account.id}: 每日赠送积分领取失败 -- 登录已失效，需要重新登录`)
+      } else if (result.error !== undefined) {
+        ctx.logger.warn(`[loomy] ${account.id}: 每日赠送积分领取失败 -- ${result.error}`)
+      }
+      outcomes.push({ id: account.id, ...result })
+    } catch (error) {
+      ctx.logger.warn(`[loomy] ${account.id}: 每日赠送积分领取异常 -- ${error instanceof Error ? error.message : String(error)}`)
+      outcomes.push({ id: account.id, error: error instanceof Error ? error.message : String(error) })
+    }
+  }
+  return outcomes
+}
+
+/** Format one account's balance line for the command output. */
+function creditsLine(credits) {
+  if (credits === undefined) return '积分：读取失败'
+  const daily = typeof credits.dailyBalance === 'number' ? `${credits.dailyBalance}/${credits.dailyQuota}` : '未知'
+  const permanent = typeof credits.permanentBalance === 'number' ? String(credits.permanentBalance) : '未知'
+  return `每日赠送 ${daily}　长期 ${permanent}　合计 ${credits.availableBalance ?? '未知'}`
+}
+
+/**
+ * `/loomy` -- the command surface.
+ *
+ * Deliberately small: the Settings panel is where the interactive work happens, and a
+ * command that duplicates it would be a second implementation to keep in sync. What a
+ * command is genuinely better at is the two things that happen before the UI is
+ * trustworthy — logging in, and finding out why a model is not answering.
+ */
+async function executeCommand(ctx, adapters, invocation) {
+  const input = String(invocation.rawInput ?? '').trim()
+  const parts = input.split(/\s+/u).filter((part) => part.length > 0)
+  const verb = (parts[0] ?? '').toLowerCase()
+
+  if (verb === '' || verb === 'status') {
+    const accounts = accountsWithState()
+    if (accounts.length === 0) {
+      return {
+        kind: 'success',
+        text: [
+          '还没有登录任何 Loomy 账号。',
+          '',
+          '  /loomy login <手机号>   用短信验证码登录',
+          '  /loomy import [目录]    导入 Loomy 桌面端已有的登录（默认只读本用户目录）',
+          '',
+          '登录也可以在「设置 → Loomy」里完成。'
+        ].join('\n')
+      };
+    }
+    const lines = []
+    for (const account of accounts) {
+      const adapter = adapters[account.id]
+      const expired = expiredInfo(account.id)
+      const state = expired === undefined ? '已登录' : `登录已失效（${formatWhen(expired.at)}）`
+      lines.push(`${account.id}${account.label.length > 0 && account.label !== account.id ? `（${account.label}）` : ''}　${state}`)
+      lines.push(`  路由：${providerFor(account.id)}`);
+      if (account.phone.length > 0) lines.push(`  手机：${account.phone}`);
+      if (expired === undefined && account.session.length > 0) {
+        try {
+          const credits = await fetchCredits(account.session)
+          anchorLedger(account.id, credits, '状态查询')
+          lines.push(`  ${creditsLine(credits)}`);
+          const grant = grantedToday(account.id) ? '今日已领取' : '今日尚未领取';
+          lines.push(`  每日额度：${grant}`);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error)
+          lines.push(`  积分：读取失败 -- ${message}`);
+          if (error?.isAuthError === true) markExpired(account.id, message);
+        }
+        if (adapter !== undefined) {
+          try {
+            adapter.invalidateCatalog()
+            const catalog = await adapter.models()
+            lines.push(`  模型：${catalog.length} 个（来源 ${adapter.catalogSource}）`);
+          } catch (error) {
+            lines.push(`  模型：读取失败 -- ${error instanceof Error ? error.message : String(error)}`);
+          }
+        }
+      }
+    }
+    lines.push('', '命令：/loomy login <手机号>、login code <验证码>、import、logout [id]、models [id]、credits [id]、tasks [id]、claim [id]');
+    return { kind: 'success', text: lines.join('\n') }
+  }
+
+  if (verb === 'login') {
+    const sub = (parts[1] ?? '').toLowerCase()
+
+    // The two-step flow keeps state in memory rather than on disk: an SMS code lives
+    // for five minutes, and persisting a half-finished login would leave a stale msgid
+    // for the next attempt to trip over.
+    if (sub === 'code') {
+      const pending = pendingLogin
+      if (pending === undefined || pending.expiresAt < Date.now()) {
+        pendingLogin = undefined
+        return { kind: 'error', text: '没有进行中的登录（或已过期），请先运行 /loomy login <手机号>' }
+      }
+      try {
+        const account = await loginBySmsCode({ phone: pending.phone, code: parts[2], msgid: pending.msgid, label: pending.label })
+        pendingLogin = undefined
+        mountAccount(ctx, adapters, account);
+        await ensureDailyGrant(account.id, account.session, { reason: '登录后' })
+        return {
+          kind: 'success',
+          text: [`登录成功：${account.id}（${account.phone}）`, `模型路由：${providerFor(account.id)}`, '', '现在可以在模型选择器里选 Loomy 了。'].join('\n')
+        }
+      } catch (error) {
+        return { kind: 'error', text: `验证码登录失败：${error instanceof Error ? error.message : String(error)}` }
+      }
+    }
+
+    const phone = parts[1] ?? ''
+    if (phone.length === 0) {
+      return { kind: 'error', text: '用法：/loomy login <手机号>　（或 /loomy import [目录] 导入桌面端登录）' }
+    }
+    try {
+      const sent = await sendSmsCode(phone)
+      pendingLogin = { phone: sent.phone, msgid: sent.msgid, label: '', expiresAt: Date.now() + (sent.expire * 1000) };
+      return {
+        kind: 'success',
+        text: [`验证码已发送到 ${sent.phone}（${sent.expire} 秒内有效）。`, '', `接着运行：/loomy login code <验证码>`].join('\n')
+      }
+    } catch (error) {
+      return { kind: 'error', text: `发送验证码失败：${error instanceof Error ? error.message : String(error)}` }
+    }
+  }
+
+  if (verb === 'import') {
+    // An optional directory: the client's layout can differ from the default, and naming
+    // it is the user's own call. Without one, only this user's own directories are read.
+    const directory = parts[1] ?? ''
+    try {
+      const result = await importDesktopAccount({ directory })
+      mountAccount(ctx, adapters, result.record);
+      await ensureDailyGrant(result.record.id, result.record.session, { reason: '导入后' })
+      return {
+        kind: 'success',
+        text: [`已导入 Loomy 桌面端登录：${result.record.id}（${result.record.phone || result.record.userid}）`, `模型路由：${providerFor(result.record.id)}`].join('\n')
+      }
+    } catch (error) {
+      return { kind: 'error', text: `导入失败：${error instanceof Error ? error.message : String(error)}` }
+    }
+  }
+
+  if (verb === 'logout') {
+    const target = parts[1] ?? (readAccounts()[0]?.id ?? '')
+    if (target.length === 0) return { kind: 'error', text: '没有可退出的账号' }
+    const account = accountOf(target)
+    if (account === undefined) return { kind: 'error', text: `未找到账号 "${target}"` }
+    await logoutRemote(account.session)
+    removeAccount(account.id)
+    adapters[account.id]?.dispose?.()
+    delete adapters[account.id]
+    return { kind: 'success', text: `已退出 ${account.id}` }
+  }
+
+  // The remaining verbs all answer "about one account", defaulting to the first.
+  const targetId = parts[1] ?? (readAccounts()[0]?.id ?? '')
+  const account = accountOf(targetId)
+  if (account === undefined) {
+    return { kind: 'error', text: `未找到账号 "${targetId}"（先运行 /loomy status 看看有哪些）` }
+  }
+  const adapter = adapters[account.id]
+
+  if (verb === 'models') {
+    if (adapter === undefined) return { kind: 'error', text: `${account.id} 的模型路由未挂载` }
+    adapter.invalidateCatalog()
+    try {
+      const catalog = await adapter.models()
+      const lines = [`${account.id}：${catalog.length} 个模型（来源 ${adapter.catalogSource}）`]
+      for (const entry of catalog) {
+        const flags = [
+          entry.type === 'image' ? '生图' : '',
+          entry.vision ? '可读图' : '',
+          entry.toolCalls ? '工具' : '',
+          entry.reasoning ? '推理' : ''
+        ].filter((flag) => flag.length > 0).join('/')
+        // A generation model cannot serve a chat turn, so it is marked rather than
+        // hidden: "why is my model missing" is worse than "this one is not for chat".
+        lines.push(`  ${entry.id} -- ${entry.name}${flags.length > 0 ? `（${flags}）` : ''}${entry.type === 'image' ? ' [不支持对话]' : ''}`)
+      }
+      return { kind: 'success', text: lines.join('\n') }
+    } catch (error) {
+      return { kind: 'error', text: `读取模型列表失败：${error instanceof Error ? error.message : String(error)}` }
+    }
+  }
+
+  if (verb === 'credits') {
+    if (isExpired(account.id)) {
+      return { kind: 'error', text: `${account.id} 的登录已失效，请重新登录` }
+    }
+    try {
+      const credits = await fetchCredits(account.session)
+      anchorLedger(account.id, credits, '积分查询')
+      const lines = [
+        `${account.id}：`, 
+        `  ${creditsLine(credits)}`,
+        `  今日消耗 ${credits.dailyConsumed}　周期 ${credits.dailyCycleDate}`,
+        `  今日赠送：${grantedToday(account.id) ? '已领取' : '尚未领取'}`
+      ]
+      return { kind: 'success', text: lines.join('\n') }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      if (error?.isAuthError === true) markExpired(account.id, message)
+      return { kind: 'error', text: `读取积分失败：${message}` }
+    }
+  }
+
+  if (verb === 'claim') {
+    const result = await ensureDailyGrant(account.id, account.session, { force: true, reason: '手动' })
+    if (result.error !== undefined) return { kind: 'error', text: `领取失败：${result.error}` }
+    return {
+      kind: 'success',
+      text: [`${account.id}：每日赠送 ${result.balance ?? 0}/${result.quota ?? 0}${result.granted ? '（今日额度已就绪）' : ''}`].join('\n')
+    }
+  }
+
+  if (verb === 'tasks') {
+    try {
+      const onboarding = await fetchOnboardingTasks(account.session)
+      const lines = [`${account.id}：新手任务 ${onboarding.earned}/${onboarding.total}`]
+      for (const [key, done] of Object.entries(onboarding.tasks)) {
+        lines.push(`  ${done ? '[x]' : '[ ]'} ${key}`)
+      }
+      const open = Object.entries(onboarding.tasks).filter(([, done]) => done !== true).map(([key]) => key)
+      if (open.length > 0) lines.push('', `可领取：/loomy claimtask ${open[0]}`, '（任务奖励是每次账号只有一份的长期积分，不会自动领取）')
+      return { kind: 'success', text: lines.join('\n') }
+    } catch (error) {
+      return { kind: 'error', text: `读取新手任务失败：${error instanceof Error ? error.message : String(error)}` }
+    }
+  }
+
+  if (verb === 'claimtask') {
+    const key = parts[2] ?? ''
+    if (key.length === 0) return { kind: 'error', text: '用法：/loomy claimtask <任务名>（先运行 /loomy tasks 查看）' }
+    try {
+      const result = await completeOnboardingTask(account.session, key)
+      return {
+        kind: 'success',
+        text: [`${account.id}：${key} ${result.alreadyCompleted ? '此前已完成' : '已完成'}，当前永久积分 ${result.balance}`].join('\n')
+      }
+    } catch (error) {
+      return { kind: 'error', text: `完成任务失败：${error instanceof Error ? error.message : String(error)}` }
+    }
+  }
+
+  return { kind: 'error', text: `未知子命令 "${verb}"。请使用 status、login、import、logout、models、credits、claim、tasks 或 claimtask。` }
+}
+
+/**
+ * Register (or refresh) the provider route for one account.
+ *
+ * `registerAdapter` is all-or-nothing per call and throws on a duplicate route, so a
+ * re-login of an already-mounted account has to drop the old registration first — which
+ * is what the returned disposer is for. Called from every path that can produce an
+ * account: boot, SMS login, desktop import, and the panel.
+ */
+export function mountAccount(ctx, adapters, account) {
+  adapters[account.id]?.dispose?.()
+  delete adapters[account.id]
+  const provider = providerFor(account.id)
+  const adapter = new LoomyAdapter(ctx, account, provider)
+  const handle = ctx.llm.registerAdapter([provider], adapter)
+  adapter.dispose = () => {
+    try {
+      handle()
+    } catch {
+      // already released
+    }
+  };
+  adapters[account.id] = adapter
+  ctx.logger.info(`[loomy] 已注册模型路由 ${provider}（账号 ${account.id}）`)
+  return adapter
+}
+
+export function apply(ctx, config) {
+  // Every load gets a short tag: the host can hold more than one instance alive across
+  // reloads, and their timers then interleave in the log.
+  const instance = randomUUID().slice(0, 4)
+  /** @type {Record<string, LoomyAdapter>} */
+  const adapters = {}
+
+  // Mount every stored account before anything waits on the network, so the model picker
+  // has routes as soon as the plugin is applied. An account whose session turns out to be
+  // dead still gets a route; its requests fail with AUTH, which the panel explains.
+  for (const account of readAccounts()) mountAccount(ctx, adapters, account)
+
+  ctx.commands.register({
+    definitionId: 'dsh-loomy',
+    name: 'loomy',
+    description: '登录并管理 Loomy 账号（每日赠送 5000 积分），把 Loomy 模型接入 DSH',
+    input: { hint: '[status|login|import|logout|models|credits|claim|tasks]' },
+    handler: (invocation) => executeCommand(ctx, adapters, invocation)
+  })
+
+  // Settings panel surface. Optional: a composition without an HTTP carrier (headless
+  // runs) keeps the provider routes and the command.
+  ctx.inject(['webServer'], (webCtx) => {
+    webCtx.effect(
+      () => registerLoomyApi(webCtx, {
+        adapters,
+        mountAccount: (account) => mountAccount(ctx, adapters, account),
+        unmountAccount: (id) => {
+          adapters[id]?.dispose?.()
+          delete adapters[id]
+        },
+        runDailyGrant: (reason) => runDailyGrant(ctx, reason)
+      }),
+      'dsh-loomy: /loomy HTTP routes'
+    )
+  })
+
+  // Boot: claim the day's credits, and point a fresh install at the ways in.
+  //
+  // Nothing is imported here on purpose. Adopting a desktop login is a decision, and the
+  // desktop client parks its session under C:\Users\Public\Loomy — a directory shared by
+  // every local user — so a silent import on first start is how a plugin ends up holding
+  // someone else's account. `/loomy import` and the panel button do the same work, on
+  // request, for this user's own directories.
+  const bootTimer = setTimeout(() => {
+    void (async () => {
+      // The daily claim, which is the whole point of the timer.
+      await runDailyGrant(ctx, '启动')
+    })().catch((error) => {
+      ctx.logger.warn(`[loomy] 启动初始化失败 -- ${error instanceof Error ? error.message : String(error)}`);
+    })
+  }, GRANT_BOOT_DELAY_MS)
+  bootTimer.unref?.()
+
+  // Daily claim at local midnight. The endpoint is idempotent per day, so a missed run
+  // costs nothing: the next one simply claims the day that is now current.
+  let midnightTimer
+  const scheduleMidnight = () => {
+    midnightTimer = setTimeout(() => {
+      void runDailyGrant(ctx, '午夜').catch(() => {})
+      scheduleMidnight()
+    }, msUntilNextMidnight())
+    midnightTimer.unref?.()
+  };
+  scheduleMidnight()
+
+  ctx.logger.info(`[loomy] 已注册 ${Object.keys(adapters).length} 个模型路由；网关 ${GATEWAY_BASE_URL}（实例 ${instance}）`)
+  if (Object.keys(adapters).length === 0) {
+    ctx.logger.info('[loomy] 还没有账号：运行 /loomy import 导入本机 Loomy 桌面端登录，或 /loomy login <手机号> 短信登录')
+  }
+
+  ctx.effect(() => () => {
+    ctx.logger.info(`[loomy] 定时器全部撤销（实例 ${instance}）`)
+    clearTimeout(bootTimer)
+    clearTimeout(midnightTimer)
+  }, 'dsh-loomy: daily credit timers')
+}