@botcord/daemon 0.2.51 → 0.2.53

package/src/index.ts

@@ -231,6 +231,44 @@ function pidAlive(pid: number): boolean {
   }
 }
 
+async function waitForPidExit(pid: number, timeoutMs: number): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!pidAlive(pid)) return true;
+    await delay(100);
+  }
+  return !pidAlive(pid);
+}
+
+async function stopExistingDaemonForRestart(pid: number): Promise<void> {
+  if (pid === process.pid) return;
+  log.info("existing daemon found; restarting", { pid });
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    try {
+      unlinkSync(PID_PATH);
+    } catch {
+      // ignore
+    }
+    return;
+  }
+  if (!(await waitForPidExit(pid, 5_000))) {
+    log.warn("existing daemon did not stop after SIGTERM; sending SIGKILL", { pid });
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+      // ignore
+    }
+    await waitForPidExit(pid, 2_000);
+  }
+  try {
+    unlinkSync(PID_PATH);
+  } catch {
+    // ignore
+  }
+}
+
 /**
  * Load the daemon config, auto-creating `~/.botcord/daemon/config.json`
  * with sensible defaults on first run. `--agent` (repeated) pins explicit
@@ -323,9 +361,11 @@ async function redeemInstallToken(opts: {
   hubUrl: string;
   installToken: string;
   label?: string;
+  daemonInstanceId?: string;
 }): Promise<DaemonTokenResponse> {
   const body: Record<string, unknown> = { install_token: opts.installToken };
   if (opts.label) body.label = opts.label;
+  if (opts.daemonInstanceId) body.daemon_instance_id = opts.daemonInstanceId;
   const resp = await fetch(`${opts.hubUrl.replace(/\/+$/, "")}/daemon/auth/install-token`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
@@ -334,7 +374,9 @@ async function redeemInstallToken(opts: {
   });
   if (!resp.ok) {
     const text = await resp.text().catch(() => "");
-    throw new Error(`daemon install-token redeem failed: ${resp.status} ${text}`);
+    const err = new Error(`daemon install-token redeem failed: ${resp.status} ${text}`);
+    (err as unknown as { status?: number }).status = resp.status;
+    throw err;
   }
   return parseDaemonTokenResponse(await resp.json(), opts.hubUrl);
 }
@@ -418,10 +460,10 @@ async function runDeviceCodeFlow(opts: {
  * plane (legacy P0 behavior — caller may still log a warning).
  *
  * Decision tree (plan §4.4 + §6.4):
- * 1. Have existing creds and no `--relogin` → return existing record, even
- *    when a dashboard `--install-token` is present. The token is one-time and
- *    the generated install command should be safe to re-run after first login.
- * 2. No existing creds + `--install-token` → redeem the one-time dashboard ticket.
+ * 1. `--install-token` → redeem the one-time dashboard ticket. If local
+ *    user-auth exists, include its daemonInstanceId so Hub can re-authorize
+ *    the same device instead of creating a new one.
+ * 2. Have existing creds and no `--relogin` → return existing record.
  * 3. `--relogin` → device-code login.
  * 4. No creds + TTY → device-code login.
  * 5. No creds + no TTY → exit 1 with the §6.4 hint.
@@ -452,9 +494,6 @@ 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; pass --relogin to re-bind");
-    }
     return existing;
   }
 
@@ -463,13 +502,37 @@ async function ensureUserAuthForStart(args: ParsedArgs): Promise<UserAuthRecord
   const label = labelFlag ?? defaultLoginLabel();
 
   if (authAction === "install-token" && installToken) {
-    const tok = await redeemInstallToken({ hubUrl, installToken, label });
-    const record = userAuthFromTokenResponse(tok, { label });
+    let tok: DaemonTokenResponse;
+    try {
+      tok = await redeemInstallToken({
+        hubUrl,
+        installToken,
+        label,
+        daemonInstanceId: existing?.daemonInstanceId,
+      });
+    } catch (err) {
+      if (existing && !relogin && !existsSync(AUTH_EXPIRED_FLAG_PATH)) {
+        console.error(
+          `note: --install-token could not be redeemed (${err instanceof Error ? err.message : String(err)}); reusing existing daemon auth`,
+        );
+        return existing;
+      }
+      throw err;
+    }
+    const record = userAuthFromTokenResponse(tok, {
+      label,
+      loggedInAt:
+        existing?.daemonInstanceId && existing.daemonInstanceId === tok.daemonInstanceId
+          ? existing.loggedInAt
+          : undefined,
+    });
     saveUserAuth(record);
     clearAuthExpiredFlag();
     log.info("install-token flow: authorized", {
       userId: record.userId,
       daemonInstanceId: record.daemonInstanceId,
+      reusedExistingDaemonInstance:
+        existing?.daemonInstanceId === record.daemonInstanceId,
       hubUrl: record.hubUrl,
       label,
     });
@@ -527,12 +590,6 @@ async function cmdStart(args: ParsedArgs): Promise<void> {
     child: process.env.BOTCORD_DAEMON_CHILD === "1",
   });
 
-  const existing = readPid();
-  if (existing && pidAlive(existing)) {
-    console.error(`daemon already running (pid ${existing})`);
-    process.exit(1);
-  }
-
   // Login MUST happen before fork — once detached, stdio is gone and the
   // user can't see the device code. We also run it for explicit
   // --foreground so an interactive user can log in without the fork dance.
@@ -540,6 +597,16 @@ async function cmdStart(args: ParsedArgs): Promise<void> {
   // var so we don't try to re-prompt for credentials it already has.
   if (process.env.BOTCORD_DAEMON_CHILD !== "1") {
     await ensureUserAuthForStart(args);
+    const existing = readPid();
+    if (existing && pidAlive(existing)) {
+      await stopExistingDaemonForRestart(existing);
+    }
+  } else {
+    const existing = readPid();
+    if (existing && existing !== process.pid && pidAlive(existing)) {
+      console.error(`daemon already running (pid ${existing})`);
+      process.exit(1);
+    }
   }
 
   if (background) {

package/src/openclaw-discovery.ts

@@ -34,8 +34,8 @@ export interface MergeOpenclawGatewayResult {
   added: OpenclawGatewayProfile[];
 }
 
-const DEFAULT_SEARCH_PATHS = ["~/.openclaw/", "/etc/openclaw/"];
-const DEFAULT_PORTS = [18789, 16200];
+const DEFAULT_SEARCH_PATHS = ["~/.openclaw/", "~/.qclaw/", "/etc/openclaw/"];
+const DEFAULT_PORTS = [18789, 16200, 28789];
 const DEFAULT_TOKEN_FILE_PATHS = [
   "/run/openclaw/gateway-token",
   "/var/run/openclaw/gateway-token",
@@ -382,6 +382,8 @@ function discoverFromConfigDir(root: string): DiscoveredOpenclawGateway[] {
 
 function parseJsonConfig(raw: string): { url?: string; token?: string; tokenFile?: string } | null {
   const obj = JSON.parse(raw) as any;
+  const qclaw = pickQclawGatewayValues(obj);
+  if (qclaw) return qclaw;
   // Prefer OpenClaw's native shape: `gateway.port` + `gateway.auth.token`.
   // The legacy `acp.url` shape is also supported for explicit user-authored configs.
   const native = pickOpenclawGatewayValues(obj?.gateway);
@@ -390,6 +392,35 @@ function parseJsonConfig(raw: string): { url?: string; token?: string; tokenFile
   return pickConfigValues(acp);
 }
 
+function pickQclawGatewayValues(
+  obj: any,
+): { url?: string; token?: string; tokenFile?: string } | null {
+  if (!obj || typeof obj !== "object") return null;
+  const port = typeof obj.port === "number" ? obj.port : undefined;
+  const configPath = typeof obj.configPath === "string" && obj.configPath.trim()
+    ? obj.configPath.trim()
+    : undefined;
+  if (!port && !configPath) return null;
+
+  const fromConfig = configPath ? readGatewayValuesFromConfigPath(configPath) : null;
+  if (fromConfig) return fromConfig;
+  if (!port) return null;
+  return { url: `ws://127.0.0.1:${port}` };
+}
+
+function readGatewayValuesFromConfigPath(
+  configPath: string,
+): { url?: string; token?: string; tokenFile?: string } | null {
+  try {
+    const raw = readFileSync(expandHome(configPath), "utf8");
+    const parsed = parseJsonConfig(raw);
+    if (parsed?.url) return parsed;
+  } catch {
+    // qclaw.json may be copied without its referenced openclaw.json.
+  }
+  return null;
+}
+
 function pickOpenclawGatewayValues(
   gw: any,
 ): { url?: string; token?: string; tokenFile?: string } | null {

package/src/provision.ts

@@ -1362,9 +1362,9 @@ export async function adoptDiscoveredOpenclawAgents(ctx: {
 function localOpenclawAcpDisabled(rawUrl: string): boolean {
   if (!isLoopbackUrl(rawUrl)) return false;
   try {
-    const file = path.join(homedir(), ".openclaw", "openclaw.json");
-    if (!existsSync(file)) return false;
-    const cfg = JSON.parse(readFileSync(file, "utf8")) as any;
+    const source = pickLocalOpenclawConfig(rawUrl);
+    if (!source) return false;
+    const cfg = JSON.parse(readFileSync(source.file, "utf8")) as any;
     return cfg?.acp?.enabled === false;
   } catch {
     return false;
@@ -1838,12 +1838,13 @@ export async function probeOpenclawAgents(
     token: prepared.resolvedToken,
     timeoutMs: opts.timeoutMs ?? 3000,
   });
-  // For loopback gateways the agent roster lives in `~/.openclaw/openclaw.json`
+  // For loopback gateways the agent roster lives in local OpenClaw config
+  // (`~/.openclaw/openclaw.json`, or QClaw's `~/.qclaw/openclaw.json`)
   // and is the source of truth — listing it over the wire would require a
   // paired device identity (operator.read scope). When the WS probe is the
   // default (i.e. no test injection) we enrich the result from disk.
   if (result.ok && !result.agents && !opts.probe && isLoopbackUrl(profile.url)) {
-    const local = readLocalOpenclawAgents();
+    const local = readLocalOpenclawAgents(profile.url);
     if (local && local.length > 0) result.agents = local;
   }
   return result;
@@ -1858,22 +1859,23 @@ function isLoopbackUrl(raw: string): boolean {
   }
 }
 
-function readLocalOpenclawAgents(): Array<{
+function readLocalOpenclawAgents(rawUrl?: string): Array<{
   id: string;
   name?: string;
   workspace?: string;
   model?: { name?: string; provider?: string };
 }> | null {
   try {
-    const file = path.join(homedir(), ".openclaw", "openclaw.json");
-    if (!existsSync(file)) return readLocalOpenclawAgentDirs() ?? [{ id: "default" }];
+    const source = pickLocalOpenclawConfig(rawUrl);
+    if (!source) return readLocalOpenclawAgentDirs(path.join(homedir(), ".openclaw")) ?? [{ id: "default" }];
+    const { file, stateDir } = source;
     const cfg = JSON.parse(readFileSync(file, "utf8")) as any;
     const list = Array.isArray(cfg?.agents?.list) ? cfg.agents.list : [];
     const explicitDefaultId =
       typeof cfg?.agents?.defaults?.id === "string" && cfg.agents.defaults.id
         ? cfg.agents.defaults.id
         : null;
-    const dirAgents = readLocalOpenclawAgentDirs();
+    const dirAgents = readLocalOpenclawAgentDirs(stateDir);
     const defaultId = explicitDefaultId ?? (list.length === 0 && !dirAgents ? "default" : null);
     const seen = new Set<string>();
     const out: Array<{ id: string; name?: string; workspace?: string; model?: { name?: string; provider?: string } }> = [];
@@ -1906,18 +1908,50 @@ function readLocalOpenclawAgents(): Array<{
   }
 }
 
-function readLocalOpenclawAgentDirs(): Array<{
+function pickLocalOpenclawConfig(rawUrl?: string): { file: string; stateDir: string } | null {
+  const candidates = [
+    { file: path.join(homedir(), ".openclaw", "openclaw.json"), stateDir: path.join(homedir(), ".openclaw") },
+    { file: path.join(homedir(), ".qclaw", "openclaw.json"), stateDir: path.join(homedir(), ".qclaw") },
+  ];
+  const targetPort = urlPort(rawUrl);
+  let firstExisting: { file: string; stateDir: string } | null = null;
+  for (const candidate of candidates) {
+    if (!existsSync(candidate.file)) continue;
+    firstExisting ??= candidate;
+    if (!targetPort) continue;
+    try {
+      const cfg = JSON.parse(readFileSync(candidate.file, "utf8")) as any;
+      if (Number(cfg?.gateway?.port) === targetPort) return candidate;
+    } catch {
+      // Try the next local config.
+    }
+  }
+  return firstExisting;
+}
+
+function urlPort(rawUrl?: string): number | null {
+  if (!rawUrl) return null;
+  try {
+    const u = new URL(rawUrl);
+    const port = Number(u.port || (u.protocol === "wss:" ? 443 : 80));
+    return Number.isInteger(port) && port > 0 ? port : null;
+  } catch {
+    return null;
+  }
+}
+
+function readLocalOpenclawAgentDirs(stateDir: string): Array<{
   id: string;
   workspace?: string;
 }> | null {
   try {
-    const dir = path.join(homedir(), ".openclaw", "agents");
+    const dir = path.join(stateDir, "agents");
     if (!existsSync(dir)) return null;
     const agents = readdirSync(dir, { withFileTypes: true })
       .filter((entry) => entry.isDirectory() && entry.name.length > 0)
       .map((entry) => ({
         id: entry.name,
-        workspace: path.join(dir, entry.name),
+        workspace: resolveAgentDirWorkspace(dir, entry.name),
       }));
     if (agents.length === 0) return null;
     agents.sort((a, b) => {
@@ -1931,6 +1965,11 @@ function readLocalOpenclawAgentDirs(): Array<{
   }
 }
 
+function resolveAgentDirWorkspace(agentsDir: string, agentId: string): string {
+  const nested = path.join(agentsDir, agentId, "agent");
+  return existsSync(nested) ? nested : path.join(agentsDir, agentId);
+}
+
 function resolveOpenclawIdentityName(
   agentId: string,
   workspace?: string,

package/src/start-auth.ts

@@ -7,7 +7,7 @@ export function resolveStartAuthAction(opts: {
   relogin: boolean;
   installToken?: string;
 }): StartAuthAction {
-  if (opts.existing && !opts.relogin) return "reuse-existing";
   if (opts.installToken) return "install-token";
+  if (opts.existing && !opts.relogin) return "reuse-existing";
   return "device-code";
 }

package/src/turn-text.ts

@@ -76,6 +76,17 @@ function replyDeliveryHint(msg: GatewayInboundMessage): string {
     : NON_OWNER_REPLY_HINT;
 }
 
+function appendConversationFields(
+  fields: string[],
+  msg: GatewayInboundMessage,
+): void {
+  const conversationId = sanitizeSenderName(msg.conversation.id);
+  fields.push(`conversation_id: ${conversationId}`);
+  if (isThirdPartyConversation(msg.conversation.id)) {
+    fields.push(`channel: ${sanitizeSenderName(msg.channel)}`);
+  }
+}
+
 /** Minimal shape of one batched inbound entry. Matches the BotCord channel
  * `BatchedInboxRaw.batch[]` elements but expressed structurally so the
  * composer doesn't import channel internals. */
@@ -205,6 +216,7 @@ export function composeBotCordUserTurn(msg: GatewayInboundMessage): string {
     `from: ${sanitizedSenderLabel}`,
     `to: ${msg.accountId}`,
   ];
+  appendConversationFields(headerFields, msg);
   if (isGroup && roomTitle) {
     const safeRoom = sanitizeSenderName(roomTitle.replace(/[\r\n]+/g, " "));
     headerFields.push(`room: ${safeRoom}`);
@@ -267,6 +279,7 @@ function composeBatchedTurn(
     `[BotCord Messages (${batch.length} new)]`,
     `to: ${msg.accountId}`,
   ];
+  appendConversationFields(header, msg);
   if (isGroup && roomTitle) {
     const safeRoom = sanitizeSenderName(roomTitle.replace(/[\r\n]+/g, " "));
     header.push(`room: ${safeRoom}`);