@botcord/daemon 0.2.13 → 0.2.15

package/src/gateway/types.ts

@@ -247,6 +247,19 @@ export interface ChannelStreamBlockContext {
   log: GatewayLogger;
 }
 
+/**
+ * Context passed to `ChannelAdapter.typing()` when the dispatcher signals
+ * "agent has accepted this turn but no execution block has surfaced yet".
+ * Adapters that bridge to a presence-style API (BotCord `/hub/typing`, etc.)
+ * map this into a one-shot ephemeral notification.
+ */
+export interface ChannelTypingContext {
+  traceId: string;
+  accountId: string;
+  conversationId: string;
+  log: GatewayLogger;
+}
+
 /** Upstream messaging surface such as BotCord, Telegram, or WeChat. */
 export interface ChannelAdapter {
   readonly id: string;
@@ -256,6 +269,12 @@ export interface ChannelAdapter {
   send(ctx: ChannelSendContext): Promise<ChannelSendResult>;
   status?(): ChannelStatusSnapshot;
   streamBlock?(ctx: ChannelStreamBlockContext): Promise<void>;
+  /**
+   * Optional ephemeral "agent is responding" hint. Fire-and-forget; failures
+   * must not break the turn. Channels without a presence concept should leave
+   * this undefined.
+   */
+  typing?(ctx: ChannelTypingContext): Promise<void>;
 }
 
 // ---------------------------------------------------------------------------
@@ -266,12 +285,38 @@ export interface ChannelAdapter {
 export interface StreamBlock {
   /** Raw JSON object as emitted by the underlying CLI (e.g. claude-code stream-json). */
   raw: unknown;
-  /** Normalized kind, used by channels to decide whether to forward progressive output. */
-  kind: "assistant_text" | "tool_use" | "tool_result" | "system" | "other";
+  /**
+   * Normalized kind, used by channels to decide whether to forward progressive
+   * output. `thinking` is synthesized by the dispatcher (or emitted explicitly
+   * by an adapter) to represent "the runtime is busy but has nothing visible
+   * to show yet" — see `RuntimeStatusEvent`.
+   */
+  kind: "assistant_text" | "tool_use" | "tool_result" | "system" | "thinking" | "other";
   /** 1-based sequence number within this turn. */
   seq: number;
 }
 
+/**
+ * Lightweight lifecycle event emitted by runtime adapters and consumed by the
+ * dispatcher to drive Dashboard-side `typing` / `thinking` UI states. Not
+ * exposed to channels directly — the dispatcher decides how to forward.
+ *
+ *   - `typing`   — ephemeral presence; dispatcher pings the channel's
+ *                  `typing()` API on `started`. `stopped` is observed for
+ *                  internal bookkeeping but not forwarded (frontend clears on
+ *                  stream/message arrival).
+ *   - `thinking` — trace-bound execution state; dispatcher converts each
+ *                  event into a `kind: "thinking"` stream block.
+ */
+export type RuntimeStatusEvent =
+  | { kind: "typing"; phase: "started" | "stopped" }
+  | {
+      kind: "thinking";
+      phase: "started" | "updated" | "stopped";
+      label?: string;
+      raw?: unknown;
+    };
+
 /** Options passed to a runtime adapter for a single turn. */
 export interface RuntimeRunOptions {
   text: string;
@@ -302,6 +347,14 @@ export interface RuntimeRunOptions {
   context?: Record<string, unknown>;
   /** Called for every parsed block while the turn is in progress. */
   onBlock?: (block: StreamBlock) => void;
+  /**
+   * Optional lifecycle hook for `typing` / `thinking` status. Adapters that
+   * can identify session/turn/tool transitions before any `StreamBlock` is
+   * available should emit through here so the dispatcher can drive
+   * Dashboard-side state. Errors from this callback must be swallowed
+   * by the adapter — the dispatcher's handler is fire-and-forget.
+   */
+  onStatus?: (event: RuntimeStatusEvent) => void;
   /**
    * External service endpoint required by some runtimes (first user:
    * openclaw-acp). Resolved at config-load time and passed through here per

package/src/index.ts

@@ -83,7 +83,7 @@ Usage: botcord-daemon <command> [options]
 
 Commands:
   start [--background|-d] [--relogin] [--hub <url>] [--label <name>]
-        [--agent <ag_xxx> ...] [--cwd <path>]
+        [--install-token <dit_xxx>] [--agent <ag_xxx> ...] [--cwd <path>]
                                           Start the daemon in the foreground by
                                           default. Pass --background (alias -d)
                                           to detach and return to the shell.
@@ -92,6 +92,9 @@ Commands:
                                           first. --hub defaults to ${DEFAULT_HUB}
                                           (or the URL stored in a previous
                                           login). --relogin forces re-login.
+                                          --install-token redeems a dashboard
+                                          issued one-time install ticket for
+                                          non-interactive first start.
                                           --label is sent to the Hub on connect
                                           for the dashboard device list
                                           (defaults to hostname). Non-TTY
@@ -275,6 +278,66 @@ function delay(ms: number): Promise<void> {
   return new Promise((r) => setTimeout(r, ms));
 }
 
+interface DaemonTokenResponse {
+  accessToken: string;
+  refreshToken: string;
+  expiresIn: number;
+  userId: string;
+  daemonInstanceId: string;
+  hubUrl: string;
+}
+
+function parseDaemonTokenResponse(raw: unknown, fallbackHubUrl: string): DaemonTokenResponse {
+  const obj = (raw && typeof raw === "object" ? raw : {}) as Record<string, unknown>;
+  const pick = (camel: string, snake: string): unknown => obj[camel] ?? obj[snake];
+  const accessToken = pick("accessToken", "access_token");
+  const refreshToken = pick("refreshToken", "refresh_token");
+  const expiresIn = pick("expiresIn", "expires_in");
+  const userId = pick("userId", "user_id");
+  const daemonInstanceId = pick("daemonInstanceId", "daemon_instance_id");
+  const hubUrl = pick("hubUrl", "hub_url");
+  if (typeof accessToken !== "string" || !accessToken) {
+    throw new Error("daemon auth response missing accessToken");
+  }
+  if (typeof refreshToken !== "string" || !refreshToken) {
+    throw new Error("daemon auth response missing refreshToken");
+  }
+  if (typeof userId !== "string" || !userId) {
+    throw new Error("daemon auth response missing userId");
+  }
+  if (typeof daemonInstanceId !== "string" || !daemonInstanceId) {
+    throw new Error("daemon auth response missing daemonInstanceId");
+  }
+  return {
+    accessToken,
+    refreshToken,
+    expiresIn: typeof expiresIn === "number" && expiresIn > 0 ? expiresIn : 3600,
+    userId,
+    daemonInstanceId,
+    hubUrl: typeof hubUrl === "string" && hubUrl.length > 0 ? hubUrl : fallbackHubUrl,
+  };
+}
+
+async function redeemInstallToken(opts: {
+  hubUrl: string;
+  installToken: string;
+  label?: string;
+}): Promise<DaemonTokenResponse> {
+  const body: Record<string, unknown> = { install_token: opts.installToken };
+  if (opts.label) body.label = opts.label;
+  const resp = await fetch(`${opts.hubUrl.replace(/\/+$/, "")}/daemon/auth/install-token`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(10_000),
+  });
+  if (!resp.ok) {
+    const text = await resp.text().catch(() => "");
+    throw new Error(`daemon install-token redeem failed: ${resp.status} ${text}`);
+  }
+  return parseDaemonTokenResponse(await resp.json(), opts.hubUrl);
+}
+
 /**
  * Run the device-code login flow against the given Hub. Polls every
  * `interval` seconds (the Hub may bump this) until the user authorizes
@@ -354,15 +417,17 @@ async function runDeviceCodeFlow(opts: {
  * plane (legacy P0 behavior — caller may still log a warning).
  *
  * Decision tree (plan §4.4 + §6.4):
- * 1. `--relogin` → device-code login.
- * 2. Have valid creds (not near expiry) → return existing record.
- * 3. Have stale creds → leave as-is; the control channel will refresh.
+ * 1. Have existing creds and no `--relogin` → return existing record.
+ * 2. `--install-token` → redeem the one-time dashboard ticket.
+ * 3. `--relogin` → device-code login.
  * 4. No creds + TTY → device-code login.
  * 5. No creds + no TTY → exit 1 with the §6.4 hint.
  */
 async function ensureUserAuthForStart(args: ParsedArgs): Promise<UserAuthRecord | null> {
   const hubFlag = typeof args.flags.hub === "string" ? args.flags.hub : undefined;
   const labelFlag = typeof args.flags.label === "string" ? args.flags.label : undefined;
+  const installToken =
+    typeof args.flags["install-token"] === "string" ? args.flags["install-token"] : undefined;
   const relogin = args.flags.relogin === true;
 
   const existing = safeLoadUserAuth();
@@ -383,11 +448,30 @@ async function ensureUserAuthForStart(args: ParsedArgs): Promise<UserAuthRecord
         `note: --label "${labelFlag}" ignored (already logged in as "${existing.label ?? "<unset>"}"); pass --relogin to change it`,
       );
     }
+    if (installToken) {
+      console.error("note: --install-token ignored because daemon is already logged in");
+    }
     return existing;
   }
 
   // Need a fresh login. Resolve hubUrl: explicit --hub > existing record > DEFAULT_HUB.
   const hubUrl = hubFlag ?? existing?.hubUrl ?? DEFAULT_HUB;
+  const label = labelFlag ?? defaultLoginLabel();
+
+  if (installToken) {
+    const tok = await redeemInstallToken({ hubUrl, installToken, label });
+    const record = userAuthFromTokenResponse(tok, { label });
+    saveUserAuth(record);
+    clearAuthExpiredFlag();
+    log.info("install-token flow: authorized", {
+      userId: record.userId,
+      daemonInstanceId: record.daemonInstanceId,
+      hubUrl: record.hubUrl,
+      label,
+    });
+    console.log(`Logged in as ${record.userId}`);
+    return record;
+  }
 
   if (!process.stdin.isTTY) {
     // Plan §6.4 — non-interactive environment. Fail fast with actionable
@@ -402,7 +486,6 @@ async function ensureUserAuthForStart(args: ParsedArgs): Promise<UserAuthRecord
     process.exit(1);
   }
 
-  const label = labelFlag ?? defaultLoginLabel();
   return runDeviceCodeFlow({ hubUrl, label });
 }
 

package/src/provision.ts

@@ -712,9 +712,11 @@ export async function adoptDiscoveredOpenclawAgents(ctx: {
           return;
         }
         try {
+          const name = resolveOpenclawIdentityName(oc.id, oc.workspace) ?? oc.name ?? `openclaw-${oc.id}`;
           const params: ProvisionAgentParams = {
             runtime: "openclaw-acp",
-            name: oc.name ?? `openclaw-${oc.id}`,
+            name,
+            bio: `OpenClaw agent ${oc.id} adopted from gateway ${gw.name}.`,
             openclaw: { gateway: gw.name, agent: oc.id },
           };
           const credentials = await materializeCredentials(params, freshCfg, {
@@ -1197,6 +1199,8 @@ function readLocalOpenclawAgents(): Array<{
       const row: { id: string; name?: string; workspace?: string; model?: { name?: string; provider?: string } } = { id };
       if (typeof raw?.name === "string") row.name = raw.name;
       if (typeof raw?.workspace === "string") row.workspace = raw.workspace;
+      const identityName = resolveOpenclawIdentityName(id, row.workspace, cfg);
+      if (identityName) row.name = identityName;
       const m = raw?.model;
       if (m && typeof m === "object") {
         const model: { name?: string; provider?: string } = {};
@@ -1216,6 +1220,63 @@ function readLocalOpenclawAgents(): Array<{
   }
 }
 
+function resolveOpenclawIdentityName(
+  agentId: string,
+  workspace?: string,
+  cfg?: any,
+): string | undefined {
+  const root = workspace ?? resolveOpenclawWorkspace(agentId, cfg);
+  if (!root) return undefined;
+  const file = path.join(expandHomePath(root), "IDENTITY.md");
+  try {
+    if (!existsSync(file)) return undefined;
+    return parseIdentityName(readFileSync(file, "utf8"));
+  } catch {
+    return undefined;
+  }
+}
+
+function resolveOpenclawWorkspace(agentId: string, cfg?: any): string | undefined {
+  let parsed = cfg;
+  if (!parsed) {
+    try {
+      const file = path.join(homedir(), ".openclaw", "openclaw.json");
+      if (!existsSync(file)) return undefined;
+      parsed = JSON.parse(readFileSync(file, "utf8"));
+    } catch {
+      return undefined;
+    }
+  }
+
+  const defaults = parsed?.agents?.defaults;
+  const defaultId = typeof defaults?.id === "string" && defaults.id ? defaults.id : "default";
+  if ((agentId === defaultId || agentId === "default") && typeof defaults?.workspace === "string") {
+    return defaults.workspace;
+  }
+
+  const list = Array.isArray(parsed?.agents?.list) ? parsed.agents.list : [];
+  for (const entry of list) {
+    if (entry?.id === agentId && typeof entry.workspace === "string") return entry.workspace;
+  }
+  return undefined;
+}
+
+function parseIdentityName(raw: string): string | undefined {
+  for (const line of raw.split(/\r?\n/)) {
+    const m = line.match(/^\s*-\s*\*\*Name:\*\*\s*(.+?)\s*$/i);
+    if (!m) continue;
+    const name = m[1].trim();
+    if (name && !name.startsWith("_(")) return name;
+  }
+  return undefined;
+}
+
+function expandHomePath(p: string): string {
+  if (p === "~") return homedir();
+  if (p.startsWith("~/")) return path.join(homedir(), p.slice(2));
+  return p;
+}
+
 /**
  * Async variant that includes L2 (gateway reachability) and L3 (agent listing)
  * probes for runtimes that talk to external services. Used by the production