linkshell-cli 0.2.64 → 0.2.66

package/src/runtime/acp/json-rpc.ts

@@ -0,0 +1,177 @@
+import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
+import type { AgentFraming } from "./provider-resolver.js";
+
+interface JsonRpcRequest {
+  jsonrpc: "2.0";
+  id: number | string;
+  method: string;
+  params?: unknown;
+}
+
+interface JsonRpcResponse {
+  jsonrpc: "2.0";
+  id: number | string;
+  result?: unknown;
+  error?: { code: number; message: string; data?: unknown };
+}
+
+interface JsonRpcNotification {
+  jsonrpc: "2.0";
+  method: string;
+  params?: unknown;
+}
+
+type JsonRpcMessage = JsonRpcRequest | JsonRpcResponse | JsonRpcNotification;
+
+export class JsonRpcStdioTransport {
+  private child: ChildProcessWithoutNullStreams | undefined;
+  private nextId = 1;
+  private pending = new Map<
+    number | string,
+    {
+      resolve: (value: unknown) => void;
+      reject: (error: Error) => void;
+      timer: ReturnType<typeof setTimeout>;
+    }
+  >();
+  private buffer = "";
+
+  constructor(
+    private readonly command: string,
+    private readonly framing: AgentFraming,
+    private readonly onNotification: (method: string, params: unknown) => void,
+    private readonly onRequest: (method: string, params: unknown) => Promise<unknown> | unknown,
+    private readonly onExit: (message: string) => void,
+  ) {}
+
+  start(cwd: string): void {
+    if (this.child) return;
+    this.child = spawn(this.command, {
+      cwd,
+      shell: true,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: process.env,
+    });
+    this.child.stdout.setEncoding("utf8");
+    this.child.stderr.setEncoding("utf8");
+    this.child.stdout.on("data", (chunk: string) => this.read(chunk));
+    this.child.stderr.on("data", (chunk: string) => {
+      const trimmed = chunk.trim();
+      if (trimmed) process.stderr.write(`[agent:stderr] ${trimmed}\n`);
+    });
+    this.child.on("error", (error) => this.failAll(error.message));
+    this.child.on("exit", (code, signal) => {
+      this.failAll(`ACP agent exited (code=${code ?? "null"}, signal=${signal ?? "null"})`);
+    });
+  }
+
+  request(method: string, params?: unknown, timeoutMs = 30_000): Promise<unknown> {
+    if (!this.child || this.child.stdin.destroyed) {
+      return Promise.reject(new Error("ACP agent is not running"));
+    }
+    const id = this.nextId++;
+    const message: JsonRpcRequest = { jsonrpc: "2.0", id, method, params };
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`ACP request timed out: ${method}`));
+      }, timeoutMs);
+      this.pending.set(id, { resolve, reject, timer });
+      this.write(message);
+    });
+  }
+
+  notify(method: string, params?: unknown): void {
+    this.write({ jsonrpc: "2.0", method, params });
+  }
+
+  stop(): void {
+    const child = this.child;
+    this.child = undefined;
+    if (child && !child.killed) child.kill("SIGTERM");
+    this.failAll("ACP transport stopped");
+  }
+
+  private write(message: JsonRpcMessage): void {
+    const raw = JSON.stringify(message);
+    if (this.framing === "newline") {
+      this.child?.stdin.write(`${raw}\n`);
+      return;
+    }
+    this.child?.stdin.write(`Content-Length: ${Buffer.byteLength(raw, "utf8")}\r\n\r\n${raw}`);
+  }
+
+  private read(chunk: string): void {
+    this.buffer += chunk;
+    while (this.buffer.length > 0) {
+      const contentLengthMatch = this.buffer.match(/^Content-Length:\s*(\d+)\r?\n/i);
+      if (contentLengthMatch) {
+        const headerEnd = this.buffer.indexOf("\r\n\r\n");
+        const altHeaderEnd = this.buffer.indexOf("\n\n");
+        const end = headerEnd >= 0 ? headerEnd + 4 : altHeaderEnd >= 0 ? altHeaderEnd + 2 : -1;
+        if (end < 0) return;
+        const length = Number(contentLengthMatch[1]);
+        if (this.buffer.length < end + length) return;
+        const raw = this.buffer.slice(end, end + length);
+        this.buffer = this.buffer.slice(end + length);
+        this.dispatch(raw);
+        continue;
+      }
+
+      const newline = this.buffer.indexOf("\n");
+      if (newline < 0) return;
+      const raw = this.buffer.slice(0, newline).trim();
+      this.buffer = this.buffer.slice(newline + 1);
+      if (raw) this.dispatch(raw);
+    }
+  }
+
+  private dispatch(raw: string): void {
+    let message: JsonRpcMessage;
+    try {
+      message = JSON.parse(raw) as JsonRpcMessage;
+    } catch {
+      return;
+    }
+
+    if ("id" in message && ("result" in message || "error" in message)) {
+      const pending = this.pending.get(message.id);
+      if (!pending) return;
+      this.pending.delete(message.id);
+      clearTimeout(pending.timer);
+      const response = message as JsonRpcResponse;
+      if (response.error) pending.reject(new Error(response.error.message));
+      else pending.resolve(response.result);
+      return;
+    }
+
+    if ("method" in message && "id" in message) {
+      Promise.resolve(this.onRequest(message.method, message.params))
+        .then((result) => this.write({ jsonrpc: "2.0", id: message.id, result }))
+        .catch((error) => {
+          this.write({
+            jsonrpc: "2.0",
+            id: message.id,
+            error: {
+              code: -32000,
+              message: error instanceof Error ? error.message : String(error),
+            },
+          });
+        });
+      return;
+    }
+
+    if ("method" in message) {
+      this.onNotification(message.method, message.params);
+    }
+  }
+
+  private failAll(message: string): void {
+    this.onExit(message);
+    for (const [, pending] of this.pending) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error(message));
+    }
+    this.pending.clear();
+  }
+}

package/src/runtime/acp/provider-resolver.ts

@@ -0,0 +1,37 @@
+export type AgentProvider = "codex" | "claude" | "custom";
+export type AgentProtocol = "acp" | "codex-app-server";
+export type AgentFraming = "content-length" | "newline";
+
+export interface AgentCommandConfig {
+  command: string;
+  provider: AgentProvider;
+  protocol: AgentProtocol;
+  framing: AgentFraming;
+}
+
+export function resolveAgentCommand(input: {
+  provider: AgentProvider;
+  command?: string;
+}): AgentCommandConfig | null {
+  const explicit = input.command?.trim();
+  if (explicit) {
+    const isCodexAppServer = /\bcodex\b/.test(explicit) && /\bapp-server\b/.test(explicit);
+    return {
+      provider: input.provider,
+      command: explicit,
+      protocol: isCodexAppServer ? "codex-app-server" : "acp",
+      framing: isCodexAppServer ? "newline" : "content-length",
+    };
+  }
+
+  if (input.provider === "codex") {
+    return {
+      provider: "codex",
+      command: "codex app-server --listen stdio://",
+      protocol: "codex-app-server",
+      framing: "newline",
+    };
+  }
+
+  return null;
+}

package/src/runtime/bridge-session.ts

@@ -18,6 +18,9 @@ import { ScrollbackBuffer } from "./scrollback.js";
 import { ScreenFallback } from "./screen-fallback.js";
 import { ScreenShare } from "./screen-share.js";
 import { getLanIp } from "../utils/lan-ip.js";
+import { startKeepAwake, type KeepAwakeHandle } from "../utils/keep-awake.js";
+import { AgentSessionProxy } from "./acp/agent-session.js";
+import type { AgentProvider } from "./acp/provider-resolver.js";
 
 export interface BridgeSessionOptions {
   gatewayUrl: string;
@@ -32,6 +35,10 @@ export interface BridgeSessionOptions {
   screen?: boolean;
   providerConfig: ProviderConfig;
   authToken?: string;
+  keepAwake?: boolean;
+  agentUi?: boolean;
+  agentProvider?: AgentProvider;
+  agentCommand?: string;
 }
 
 const HEARTBEAT_INTERVAL = 15_000;
@@ -39,6 +46,10 @@ const RECONNECT_BASE_DELAY = 1_000;
 const RECONNECT_MAX_DELAY = 30_000;
 const RECONNECT_MAX_ATTEMPTS = 20;
 const DEFAULT_TERMINAL_ID = "default";
+const HOOK_BODY_LIMIT = 256 * 1024;
+const PERMISSION_REQUEST_TIMEOUT_MS = Number(
+  process.env.LINKSHELL_PERMISSION_TIMEOUT_MS ?? 5 * 60_000,
+);
 
 interface TerminalInstance {
   id: string;
@@ -55,6 +66,17 @@ interface TerminalInstance {
   hookConfigPaths: string[];
 }
 
+interface PendingPermission {
+  terminalId: string;
+  timeout: ReturnType<typeof setTimeout>;
+  resolve: (decision: "allow" | "deny") => void;
+}
+
+function isLinkShellHookEntry(entry: unknown): boolean {
+  const raw = JSON.stringify(entry);
+  return /\/hook\?m=lsh-[^"'\s]+/.test(raw);
+}
+
 function getPairingGatewayParam(gatewayHttpUrl: string): string | undefined {
   try {
     const url = new URL(gatewayHttpUrl);
@@ -111,6 +133,13 @@ function resolvePairingGateway(
   }
 }
 
+function normalizeAgentProvider(provider: unknown): AgentProvider {
+  if (provider === "claude" || provider === "custom") {
+    return provider;
+  }
+  return "codex";
+}
+
 export class BridgeSession {
   private readonly options: BridgeSessionOptions;
   private socket: WebSocket | undefined;
@@ -130,11 +159,13 @@ export class BridgeSession {
     timestamp: number;
   }>>();
   // Pending permission responses: requestId → HTTP response callback
-  private pendingPermissions = new Map<string, (decision: "allow" | "deny") => void>();
+  private pendingPermissions = new Map<string, PendingPermission>();
   private hookMarker = `lsh-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
   private screenCapture: ScreenFallback | undefined;
   private screenShare: ScreenShare | undefined;
   private tunnelSockets = new Map<string, WebSocket>();
+  private keepAwake: KeepAwakeHandle | undefined;
+  private agentSession: AgentSessionProxy | undefined;
 
   constructor(options: BridgeSessionOptions) {
     this.options = options;
@@ -154,6 +185,25 @@ export class BridgeSession {
     if (!this.sessionId) {
       await this.createPairing();
     }
+    if (this.options.keepAwake) {
+      this.keepAwake = startKeepAwake();
+    } else {
+      process.stderr.write("[bridge] keep-awake disabled\n");
+    }
+    if (this.options.agentUi) {
+      const agentProvider = normalizeAgentProvider(
+        this.options.agentProvider ?? this.options.providerConfig.provider,
+      );
+      this.agentSession = new AgentSessionProxy({
+        sessionId: this.sessionId,
+        cwd: process.cwd(),
+        provider: agentProvider,
+        command: this.options.agentCommand,
+        verbose: this.options.verbose,
+        send: (envelope) => this.send(envelope),
+      });
+      process.stderr.write("[bridge] agent GUI channel enabled\n");
+    }
     await this.spawnTerminal(DEFAULT_TERMINAL_ID, process.cwd());
     this.connectGateway();
   }
@@ -261,7 +311,13 @@ export class BridgeSession {
     });
 
     this.socket.on("message", (data) => {
-      const envelope = parseEnvelope(data.toString());
+      let envelope: Envelope;
+      try {
+        envelope = parseEnvelope(data.toString());
+      } catch (err) {
+        this.log(`invalid gateway message ignored: ${err}`);
+        return;
+      }
       this.log(
         `recv ${envelope.type}${envelope.seq !== undefined ? ` seq=${envelope.seq}` : ""}`,
       );
@@ -457,7 +513,11 @@ export class BridgeSession {
         const p = parseTypedPayload("session.resume", envelope.payload);
         // Replay all terminals
         for (const [termId, term] of this.terminals) {
-          this.replayFrom(termId, term, p.lastAckedSeq);
+          this.replayFrom(
+            termId,
+            term,
+            p.lastAckedSeqByTerminal[termId] ?? p.lastAckedSeq,
+          );
         }
         // Also send terminal list so client knows what's available
         this.sendTerminalList();
@@ -484,6 +544,39 @@ export class BridgeSession {
         this.screenShare?.handleIceCandidate(p.candidate, p.sdpMid, p.sdpMLineIndex);
         break;
       }
+      case "agent.initialize":
+      case "agent.session.new":
+      case "agent.session.load":
+      case "agent.session.list":
+      case "agent.prompt":
+      case "agent.cancel":
+      case "agent.permission.response": {
+        if (!this.agentSession) {
+          this.send(
+            createEnvelope({
+              type: "agent.capabilities",
+              sessionId: this.sessionId,
+              payload: {
+                enabled: false,
+                provider: normalizeAgentProvider(
+                  this.options.agentProvider ?? this.options.providerConfig.provider,
+                ),
+                error: "Agent GUI is not enabled. Start CLI with --agent-ui.",
+                supportsSessionList: false,
+                supportsSessionLoad: false,
+                supportsImages: false,
+                supportsAudio: false,
+                supportsPermission: false,
+                supportsPlan: false,
+                supportsCancel: false,
+              },
+            }),
+          );
+          break;
+        }
+        await this.agentSession.handleEnvelope(envelope);
+        break;
+      }
       case "file.upload": {
         const p = parseTypedPayload("file.upload", envelope.payload);
         const ext = p.filename.split(".").pop() || "png";
@@ -498,20 +591,8 @@ export class BridgeSession {
       }
       case "permission.decision": {
         const p = envelope.payload as { requestId: string; decision: "allow" | "deny" };
-        const resolve = this.pendingPermissions.get(p.requestId);
-        if (resolve) {
-          this.pendingPermissions.delete(p.requestId);
-          resolve(p.decision);
+        if (this.resolvePendingPermission(p.requestId, p.decision)) {
           this.log(`permission decision for ${p.requestId}: ${p.decision}`);
-          // Pop from permission stack
-          if (p.decision === "allow" || p.decision === "deny") {
-            const stack = this.permissionStacks.get(tid);
-            if (stack) {
-              const idx = stack.findIndex((s) => s.requestId === p.requestId);
-              if (idx >= 0) stack.splice(idx, 1);
-              if (stack.length === 0) this.permissionStacks.delete(tid);
-            }
-          }
         } else {
           this.log(`no pending permission for ${p.requestId}`);
         }
@@ -889,8 +970,19 @@ export class BridgeSession {
         return;
       }
       let body = "";
-      req.on("data", (chunk: Buffer) => { body += chunk.toString(); });
+      let bodyTooLarge = false;
+      req.on("data", (chunk: Buffer) => {
+        if (bodyTooLarge) return;
+        body += chunk.toString();
+        if (Buffer.byteLength(body, "utf8") > HOOK_BODY_LIMIT) {
+          bodyTooLarge = true;
+          res.writeHead(413);
+          res.end("payload too large");
+          req.destroy();
+        }
+      });
       req.on("end", () => {
+        if (bodyTooLarge || res.writableEnded) return;
         this.log(`hook body (${body.length} bytes): ${body.slice(0, 200)}`);
         try {
           const event = JSON.parse(body);
@@ -899,15 +991,26 @@ export class BridgeSession {
           // PermissionRequest: hold connection, wait for user decision from mobile app
           if (hookName === "PermissionRequest") {
             const requestId = `pr-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-            this.pendingPermissions.set(requestId, (decision) => {
-              const responseJson = JSON.stringify({
-                hookSpecificOutput: {
-                  hookEventName: "PermissionRequest",
-                  decision: { behavior: decision },
-                },
-              });
-              res.writeHead(200, { "Content-Type": "application/json" });
-              res.end(responseJson);
+            const timeout = setTimeout(() => {
+              if (this.resolvePendingPermission(requestId, "deny")) {
+                this.log(`permission request ${requestId} timed out`);
+                this.sendPermissionSnapshot(terminalId, "thinking", "permission timed out");
+              }
+            }, PERMISSION_REQUEST_TIMEOUT_MS);
+            this.pendingPermissions.set(requestId, {
+              terminalId,
+              timeout,
+              resolve: (decision) => {
+                if (res.writableEnded) return;
+                const responseJson = JSON.stringify({
+                  hookSpecificOutput: {
+                    hookEventName: "PermissionRequest",
+                    decision: { behavior: decision },
+                  },
+                });
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(responseJson);
+              },
             });
             // Send status with requestId so app can route decision back
             this.handleHookEvent(terminalId, event, provider, requestId);
@@ -964,9 +1067,16 @@ export class BridgeSession {
     } catch { /* doesn't exist yet */ }
 
     const hookEntry = { matcher: "", hooks: [{ type: "command", command: curlCmd, timeout: 5 }] };
-    const permissionEntry = { matcher: "", hooks: [{ type: "command", command: curlCmd, timeout: 86400 }] };
+    const permissionEntry = {
+      matcher: "",
+      hooks: [{
+        type: "command",
+        command: curlCmd,
+        timeout: Math.ceil((PERMISSION_REQUEST_TIMEOUT_MS + 30_000) / 1000),
+      }],
+    };
 
-    const hookEvents: Record<string, typeof hookEntry> = {
+    const hookEvents: Record<string, typeof hookEntry | typeof permissionEntry> = {
       PreToolUse: hookEntry,
       PostToolUse: hookEntry,
       PostToolUseFailure: hookEntry,
@@ -981,7 +1091,7 @@ export class BridgeSession {
     for (const [eventName, entry] of Object.entries(hookEvents)) {
       let arr = Array.isArray(existingHooks[eventName]) ? existingHooks[eventName] : [];
       // Remove any dead linkshell hook entries (from previous instances)
-      arr = arr.filter((e) => !JSON.stringify(e).includes("/hook"));
+      arr = arr.filter((e) => !isLinkShellHookEntry(e));
       arr.push(entry);
       existingHooks[eventName] = arr;
     }
@@ -1036,7 +1146,7 @@ export class BridgeSession {
     const existingHooks = existing.hooks ?? {};
     for (const [eventName, entry] of Object.entries(hookEvents)) {
       let arr = Array.isArray(existingHooks[eventName]) ? existingHooks[eventName] : [];
-      arr = arr.filter((e) => !JSON.stringify(e).includes("/hook"));
+      arr = arr.filter((e) => !isLinkShellHookEntry(e));
       arr.push(entry);
       existingHooks[eventName] = arr;
     }
@@ -1069,7 +1179,7 @@ export class BridgeSession {
     const existingHooks = (existing.hooks ?? {}) as Record<string, unknown[]>;
     for (const [eventName, entry] of Object.entries(hookEvents)) {
       let arr = Array.isArray(existingHooks[eventName]) ? existingHooks[eventName] : [];
-      arr = arr.filter((e) => !JSON.stringify(e).includes("/hook"));
+      arr = arr.filter((e) => !isLinkShellHookEntry(e));
       arr.push(entry);
       existingHooks[eventName] = arr;
     }
@@ -1104,7 +1214,7 @@ export class BridgeSession {
     const existingHooks = existing.hooks ?? {};
     for (const [eventName, entry] of Object.entries(hookEvents)) {
       let arr = Array.isArray(existingHooks[eventName]) ? existingHooks[eventName] : [];
-      arr = arr.filter((e) => !JSON.stringify(e).includes("/hook"));
+      arr = arr.filter((e) => !isLinkShellHookEntry(e));
       arr.push(entry);
       existingHooks[eventName] = arr;
     }
@@ -1334,10 +1444,7 @@ export class BridgeSession {
 
   /** Auto-resolve a single pending permission (user acted in terminal) */
   private autoResolvePending(requestId: string): void {
-    const resolve = this.pendingPermissions.get(requestId);
-    if (resolve) {
-      this.pendingPermissions.delete(requestId);
-      resolve("allow");
+    if (this.resolvePendingPermission(requestId, "allow")) {
       this.log(`auto-resolved pending permission ${requestId} (user acted in terminal)`);
     }
   }
@@ -1346,16 +1453,53 @@ export class BridgeSession {
   private drainPendingPermissions(terminalId: string): void {
     const stack = this.permissionStacks.get(terminalId);
     if (!stack) return;
-    for (const entry of stack) {
-      const resolve = this.pendingPermissions.get(entry.requestId);
-      if (resolve) {
-        this.pendingPermissions.delete(entry.requestId);
-        resolve("deny");
+    for (const entry of [...stack]) {
+      if (this.resolvePendingPermission(entry.requestId, "deny")) {
         this.log(`drained pending permission ${entry.requestId}`);
       }
     }
   }
 
+  private resolvePendingPermission(requestId: string, decision: "allow" | "deny"): boolean {
+    const pending = this.pendingPermissions.get(requestId);
+    if (!pending) return false;
+    this.pendingPermissions.delete(requestId);
+    clearTimeout(pending.timeout);
+    pending.resolve(decision);
+
+    const stack = this.permissionStacks.get(pending.terminalId);
+    if (stack) {
+      const idx = stack.findIndex((entry) => entry.requestId === requestId);
+      if (idx >= 0) stack.splice(idx, 1);
+      if (stack.length === 0) this.permissionStacks.delete(pending.terminalId);
+    }
+    return true;
+  }
+
+  private sendPermissionSnapshot(
+    terminalId: string,
+    phase: string,
+    summary?: string,
+  ): void {
+    const stack = this.permissionStacks.get(terminalId);
+    const topPermission = stack && stack.length > 0 ? stack[stack.length - 1] : undefined;
+    const pendingPermissionCount = stack?.length ?? 0;
+    const term = this.terminals.get(terminalId);
+    const seq = term ? term.statusSeq++ : 0;
+    this.send(createEnvelope({
+      type: "terminal.status",
+      sessionId: this.sessionId,
+      terminalId,
+      payload: {
+        phase,
+        seq,
+        ...(summary && { summary }),
+        ...(topPermission && { topPermission }),
+        ...(pendingPermissionCount > 0 && { pendingPermissionCount }),
+      },
+    }));
+  }
+
   private cleanupHookServer(term: TerminalInstance): void {
     // Drain any pending permission requests for this terminal
     this.drainPendingPermissions(term.id);
@@ -1546,6 +1690,10 @@ export class BridgeSession {
     this.exited = true;
     this.stopHeartbeat();
     this.stopScreenCapture();
+    this.agentSession?.stop();
+    this.agentSession = undefined;
+    this.keepAwake?.stop();
+    this.keepAwake = undefined;
     if (this.reconnectTimer) {
       clearTimeout(this.reconnectTimer);
       this.reconnectTimer = undefined;

package/src/utils/daemon.ts

@@ -7,6 +7,11 @@ const LINKSHELL_DIR = join(homedir(), ".linkshell");
 
 type ServiceName = "gateway" | "bridge";
 
+export interface ServiceMetadata {
+  keepAwake?: boolean;
+  startedAt?: number;
+}
+
 function pidFile(service: ServiceName): string {
   return join(LINKSHELL_DIR, `${service}.pid`);
 }
@@ -15,6 +20,10 @@ function logFile(service: ServiceName): string {
   return join(LINKSHELL_DIR, `${service}.log`);
 }
 
+function metadataFile(service: ServiceName): string {
+  return join(LINKSHELL_DIR, `${service}.json`);
+}
+
 export function savePid(service: ServiceName, pid: number): void {
   mkdirSync(LINKSHELL_DIR, { recursive: true });
   writeFileSync(pidFile(service), String(pid), "utf8");
@@ -40,6 +49,7 @@ export function readPid(service: ServiceName): number | null {
 
 export function removePid(service: ServiceName): void {
   try { unlinkSync(pidFile(service)); } catch {}
+  try { unlinkSync(metadataFile(service)); } catch {}
 }
 
 export function getLogFile(service: ServiceName): string {
@@ -50,6 +60,24 @@ export function getPidFile(service: ServiceName): string {
   return pidFile(service);
 }
 
+export function saveMetadata(
+  service: ServiceName,
+  metadata: ServiceMetadata,
+): void {
+  mkdirSync(LINKSHELL_DIR, { recursive: true });
+  writeFileSync(metadataFile(service), JSON.stringify(metadata), "utf8");
+}
+
+export function readMetadata(service: ServiceName): ServiceMetadata | null {
+  try {
+    const file = metadataFile(service);
+    if (!existsSync(file)) return null;
+    return JSON.parse(readFileSync(file, "utf8")) as ServiceMetadata;
+  } catch {
+    return null;
+  }
+}
+
 export function spawnDaemon(service: ServiceName, args: string[]): number {
   mkdirSync(LINKSHELL_DIR, { recursive: true });
   const log = logFile(service);