@clawling/clawchat-plugin-openclaw 2026.7.6-2 → 2026.7.6-4

package/src/runtime.ts

@@ -17,7 +17,9 @@ import { createOpenclawClawlingClient, resolveOpenclawClawlingDeviceId } from ".
 import { createOpenclawClawlingApiClient } from "./api-client.ts";
 import { buildActivationBootstrapText } from "./activation-greeting.ts";
 import { reportPluginVersionSafe, resolvePluginVersion } from "./plugin-report.ts";
-import { ensureLivewareCli } from "./liveware-cli.ts";
+import path from "node:path";
+import { ensureLivewareCli, resolveLivewarePath } from "./liveware-cli.ts";
+import { LivewareSampleSupervisor, type LivewareSampleStoreLike } from "./liveware-sample.ts";
 import { ClawlingApiError } from "./api-types.ts";
 import { RefreshManager } from "./refresh-manager.ts";
 import {
@@ -38,6 +40,7 @@ import type { ClawlingChatClient } from "./ws-client.ts";
 import { dispatchOpenclawClawlingInbound, type IngestTurnParams } from "./inbound.ts";
 import {
   PendingConsentStore,
+  cleanupTombstonedManagedSkills,
   handleOwnerConsentReply,
   managedSkillExists,
   readLocalSkillState,
@@ -1096,6 +1099,45 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
     conversationApiClient = undefined;
   };
 
+  // Liveware Sample auto-boot (spec: docs/superpowers/specs/2026-07-06-liveware-sample-autoboot-design.md).
+  // Fire-and-forget like ensureLivewareCli above: never blocks or fails the channel.
+  // `livewareSampleNotify` is reassigned once `client`/`account` are ready (see
+  // `sendOwnerSkillMessage` below) — both live in this same function closure, so
+  // the forward reference here just resolves to the fresh value at call time.
+  let livewareSampleNotify: (text: string) => Promise<boolean> = async () => false;
+  if (store) {
+    const stateDirForSample = runtime.state?.resolveStateDir?.();
+    const livewareSampleSupervisor = new LivewareSampleSupervisor({
+      platform: "openclaw",
+      accountId,
+      enabled: account.livewareSample,
+      // `store` here is the `ClawChatStore` returned by `resolveConnectionStore`;
+      // `RuntimeConnectionStore` only `Pick`s a subset of its methods, so widen
+      // through the structural `LivewareSampleStoreLike` contract (Task 8/4).
+      store: store as unknown as LivewareSampleStoreLike,
+      sampleRoot: path.join(stateDirForSample ?? "", "clawchat", "liveware-sample"),
+      resolveToken: () => account.token ?? "",
+      resolveLivewarePath: () => resolveLivewarePath(stateDirForSample),
+      listApps: async () => {
+        const client = getConversationApiClient();
+        return await client.listApps();
+      },
+      registerApp: async (p) => {
+        const client = getConversationApiClient();
+        return await client.registerApp(p);
+      },
+      notifyOwner: (text) => livewareSampleNotify(text),
+      fetchFn: globalThis.fetch,
+      log: {
+        warn: (m) => log?.info?.(m),
+        debug: (m) => log?.debug?.(m),
+        error: (m) => log?.error?.(m),
+      },
+    });
+    abortSignal.addEventListener("abort", () => livewareSampleSupervisor.stop());
+    void livewareSampleSupervisor.start();
+  }
+
   const resolveMutateConfigFile = (): OpenclawClawchatMutateConfigFile | undefined => {
     if (params.mutateConfigFile) return params.mutateConfigFile;
     const runtimeConfig = runtime.config as unknown as {
@@ -2235,6 +2277,14 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
       }`,
     );
   }
+  // Load-time tombstone sweep: delete any managed skill copy the bundled
+  // manifest snapshot marks as removed, so a stale id from an old install
+  // stops shadowing/loading. Fire-and-forget — must never block or fail boot.
+  void cleanupTombstonedManagedSkills({
+    managedDir: managedSkillsDir,
+    bundledDir: bundledSkillsDir,
+    log,
+  }).catch(() => {});
   // A usr_... id is not a valid chat_id — member-backend rejects it with
   // "invalid conversation id" and msghub never acks the send. Proactive owner
   // messages must be addressed to the direct conversation recorded at
@@ -2263,6 +2313,21 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
       log,
     });
   };
+  // Wire the liveware-sample intro notifier now that `client`/`account` are in
+  // scope (both declared earlier in this same function body — see the
+  // `livewareSampleNotify` forward declaration above the supervisor construction).
+  livewareSampleNotify = async (text: string): Promise<boolean> => {
+    const conversationId = resolveOwnerDirectConversationId();
+    if (!conversationId) return false;
+    const result = await sendOpenclawClawlingText({
+      client,
+      account,
+      to: { chatId: conversationId, chatType: "direct" },
+      text,
+      log,
+    });
+    return result != null;
+  };
   const triggerSkillUpdateCheck = async (): Promise<void> => {
     const ownerUserId = account.ownerUserId?.trim();
     if (!ownerUserId) {

package/src/skill-update.ts

@@ -1,5 +1,5 @@
 import crypto from "node:crypto";
-import { existsSync } from "node:fs";
+import { existsSync, readdirSync } from "node:fs";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -69,9 +69,27 @@ export const MAX_SKILL_BYTES = 256 * 1024;
 /** This adapter's host target inside `skills/manifest.json`. */
 export const SKILL_TARGET = "openclaw";
 
-/** Skill ids this OpenClaw plugin bundles and can hot-update. */
-export const OPENCLAW_SKILL_IDS = ["clawchat", "liveware-app"] as const;
-export type OpenclawSkillId = (typeof OPENCLAW_SKILL_IDS)[number];
+/**
+ * Skill ids bundled with this plugin, discovered by scanning the bundled
+ * skills dir. Returns [] when the dir is unresolvable (managed-only mode —
+ * nothing bundled to protect from tombstones). Never hard-code this list.
+ */
+export function getBundledSkillIds(fromUrl?: string): readonly string[] {
+  let dir: string;
+  try {
+    dir = fromUrl === undefined ? resolveBundledSkillsDir() : resolveBundledSkillsDir(fromUrl);
+  } catch {
+    return [];
+  }
+  try {
+    return readdirSync(dir, { withFileTypes: true })
+      .filter((e) => e.isDirectory() && existsSync(path.join(dir, e.name, "SKILL.md")))
+      .map((e) => e.name)
+      .sort();
+  } catch {
+    return [];
+  }
+}
 
 // ---------------------------------------------------------------------------
 // Minimal fetch abstraction (compatible with the global `fetch`).
@@ -490,6 +508,50 @@ export async function atomicWriteSkill(
   }
 }
 
+/**
+ * Load-time counterpart of the dynamic removal path: delete managed copies of
+ * ids tombstoned by the bundled manifest snapshot, so stale ids from an old
+ * install stop shadowing/loading. Never throws — a bad snapshot must not
+ * break plugin startup. Returns the removed ids.
+ */
+export async function cleanupTombstonedManagedSkills(options: {
+  managedDir: string;
+  bundledDir: string | null;
+  log?: { info?: (msg: string) => void };
+}): Promise<string[]> {
+  if (!options.bundledDir) return [];
+  let removedIds: string[];
+  try {
+    const raw = await fs.readFile(path.join(options.bundledDir, "manifest.json"), "utf8");
+    const manifest = parseSkillsManifest(raw);
+    removedIds = manifest.removed[SKILL_TARGET] ?? [];
+  } catch {
+    return [];
+  }
+  const bundledIds = getBundledSkillIds();
+  const removed: string[] = [];
+  for (const id of removedIds) {
+    if (bundledIds.includes(id)) continue;
+    if (!existsSync(path.join(options.managedDir, id, "SKILL.md"))) continue;
+    // Per-id guard: one id's fs failure (EBUSY, EPERM, a directory squatting
+    // on the SKILL.md path, ...) must not reject the whole sweep nor discard
+    // the ids already removed — log it and move on to the next id.
+    try {
+      await removeManagedSkill(options.managedDir, id);
+    } catch (err) {
+      options.log?.info?.(
+        `clawchat skill-update: failed to remove tombstoned managed skill ${id} at load: ${
+          err instanceof Error ? err.message : String(err)
+        }`,
+      );
+      continue;
+    }
+    removed.push(id);
+    options.log?.info?.(`clawchat skill-update: removed tombstoned managed skill ${id} at load`);
+  }
+  return removed;
+}
+
 /**
  * Delete a tombstoned managed skill: remove `<skillsDir>/<skillId>/SKILL.md`
  * (the host chokidar-watches the dir; the unlink triggers a snapshot rebuild
@@ -684,7 +746,7 @@ export async function runSkillUpdateCheck(
 
   const removals: PendingSkillRemoval[] = [];
   for (const skillId of outcome.removedIds) {
-    if ((OPENCLAW_SKILL_IDS as readonly string[]).includes(skillId)) {
+    if (getBundledSkillIds().includes(skillId)) {
       options.log?.info?.(`clawchat skill-update: ignoring tombstone for bundled skill ${skillId}`);
       continue;
     }
@@ -810,7 +872,7 @@ export async function handleOwnerConsentReply(
       // Defensive re-guard: bundled skills must never be deleted, even though
       // runSkillUpdateCheck already filters them out of removal candidates.
       // Unreachable in the normal flow; kept as a cheap safety net.
-      if ((OPENCLAW_SKILL_IDS as readonly string[]).includes(removal.skillId)) {
+      if (getBundledSkillIds().includes(removal.skillId)) {
         options.log?.info?.(
           `clawchat skill-update: skipped removal of bundled skill ${removal.skillId} (defensive re-guard)`,
         );

package/src/storage.ts

@@ -157,6 +157,40 @@ export type ActivationConversation = {
   lastRefreshedAt: number | null;
 };
 
+export type LivewareSampleRow = {
+  platform: string;
+  account_id: string;
+  app_id: string;
+  app_name: string;
+  port: number;
+  public_url: string | null;
+  sample_version: string;
+  status: string;
+  last_error: string | null;
+  intro_sent: number;
+  created_at: number;
+  updated_at: number;
+};
+
+export type LivewareSampleUpsert = {
+  platform: string;
+  accountId: string;
+  appId: string;
+  appName: string;
+  port: number;
+  publicUrl?: string | null;
+  sampleVersion: string;
+  status: "active" | "failed" | "disabled";
+  lastError?: string | null;
+};
+
+export type UpdateLivewareSampleStatusInput = {
+  platform: string;
+  accountId: string;
+  status: "active" | "failed" | "disabled";
+  lastError?: string | null;
+};
+
 type Migration = { version: number; name: string; sql: string };
 
 const DB_FILENAME = "clawchat.sqlite";
@@ -290,6 +324,27 @@ ALTER TABLE clawchat_messages ADD COLUMN send_error TEXT;
     name: "activation_device_id",
     sql: `
 ALTER TABLE activations ADD COLUMN device_id TEXT;
+`,
+  },
+  {
+    version: 8,
+    name: "liveware_sample",
+    sql: `
+CREATE TABLE IF NOT EXISTS liveware_sample (
+  platform TEXT NOT NULL,
+  account_id TEXT NOT NULL,
+  app_id TEXT NOT NULL,
+  app_name TEXT NOT NULL,
+  port INTEGER NOT NULL,
+  public_url TEXT,
+  sample_version TEXT NOT NULL,
+  status TEXT NOT NULL,
+  last_error TEXT,
+  intro_sent INTEGER NOT NULL DEFAULT 0,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  PRIMARY KEY (platform, account_id)
+);
 `,
   },
 ];
@@ -810,6 +865,72 @@ export class ClawChatStore {
     }) ?? null;
   }
 
+  getLivewareSample(input: ConversationAccountInput): LivewareSampleRow | null {
+    return this.read(() => {
+      const row = this.requireDb()
+        .prepare(`SELECT * FROM liveware_sample WHERE platform = ? AND account_id = ?`)
+        .get(input.platform, input.accountId);
+      return (row as LivewareSampleRow | undefined) ?? null;
+    }) ?? null;
+  }
+
+  upsertLivewareSample(input: LivewareSampleUpsert): void {
+    this.write(() => {
+      const now = Date.now();
+      this.requireDb()
+        .prepare(
+          `INSERT INTO liveware_sample
+             (platform, account_id, app_id, app_name, port, public_url,
+              sample_version, status, last_error, intro_sent, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?)
+           ON CONFLICT(platform, account_id) DO UPDATE SET
+             app_id = excluded.app_id,
+             app_name = excluded.app_name,
+             port = excluded.port,
+             public_url = excluded.public_url,
+             sample_version = excluded.sample_version,
+             status = excluded.status,
+             last_error = excluded.last_error,
+             updated_at = excluded.updated_at`,
+        )
+        .run(
+          input.platform,
+          input.accountId,
+          input.appId,
+          input.appName,
+          input.port,
+          input.publicUrl ?? null,
+          input.sampleVersion,
+          input.status,
+          input.lastError ?? null,
+          now,
+          now,
+        );
+    });
+  }
+
+  updateLivewareSampleStatus(input: UpdateLivewareSampleStatusInput): void {
+    this.write(() => {
+      this.requireDb()
+        .prepare(
+          `UPDATE liveware_sample SET status = ?, last_error = ?, updated_at = ?
+           WHERE platform = ? AND account_id = ?`,
+        )
+        .run(input.status, input.lastError ?? null, Date.now(), input.platform, input.accountId);
+    });
+  }
+
+  markLivewareSampleIntroSent(input: ConversationAccountInput): void {
+    this.write(() => {
+      this.requireDb()
+        .prepare(
+          `UPDATE liveware_sample SET intro_sent = 1, updated_at = ?
+           WHERE platform = ? AND account_id = ?`,
+        )
+        .run(Date.now(), input.platform, input.accountId);
+    });
+  }
+
   recordToolCall(input: ToolCallInput): void {
     this.write(() => {
       const startedAt = input.startedAt ?? Date.now();