@awebai/claude-channel 0.2.2 → 1.0.0

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "aweb-channel",
   "description": "aweb agent coordination channel — receive mail, chat, tasks, and control signals from your agent team in real time.",
-  "version": "0.2.2",
+  "version": "1.0.0",
   "author": {
     "name": "awebai"
   },

package/dist/index.js

@@ -21261,7 +21261,7 @@ var StdioServerTransport = class {
 
 // src/index.ts
 import { join as join2 } from "node:path";
-import { homedir as homedir2 } from "node:os";
+import { homedir } from "node:os";
 import { realpathSync } from "node:fs";
 import { readFile as readFile2 } from "node:fs/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -21269,7 +21269,6 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 // src/config.ts
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
-import { homedir } from "node:os";
 
 // node_modules/js-yaml/dist/js-yaml.mjs
 function isNothing(subject) {
@@ -23897,48 +23896,48 @@ var jsYaml = {
 
 // src/config.ts
 async function resolveConfig(workdir) {
-  const globalPath = process.env.AW_CONFIG_PATH || join(homedir(), ".config", "aw", "config.yaml");
-  const contextPath = join(workdir, ".aw", "context");
   const workspacePath = join(workdir, ".aw", "workspace.yaml");
-  const globalConfig2 = await readYAML(globalPath);
-  if (!globalConfig2?.accounts || Object.keys(globalConfig2.accounts).length === 0) {
-    throw new Error(`no accounts configured in ${globalPath}`);
-  }
-  let accountName;
-  const context = await readYAML(contextPath);
-  if (context?.default_account) {
-    accountName = context.default_account;
-  } else if (context?.client_default_accounts?.aw) {
-    accountName = context.client_default_accounts.aw;
-  }
-  if (!accountName) {
-    accountName = Object.keys(globalConfig2.accounts)[0];
-  }
-  const account = globalConfig2.accounts[accountName];
-  if (!account) {
-    throw new Error(`account "${accountName}" not found in ${globalPath}`);
-  }
-  if (!account.api_key) {
-    throw new Error(`account "${accountName}" has no api_key`);
-  }
-  const serverName = account.server || "default";
-  const server = globalConfig2.servers?.[serverName];
-  const baseURL = server?.url || "https://app.aweb.ai";
-  const namespace = account.namespace_slug || "";
-  const alias = account.alias || "";
-  const address = namespace && alias ? `${namespace}/${alias}` : "";
+  const identityPath = join(workdir, ".aw", "identity.yaml");
   const workspace = await readYAML(workspacePath);
-  const projectSlug = account.default_project || workspace?.project_slug || "";
+  if (!workspace) {
+    throw new Error("current directory is not initialized for aw; run `aw init` or `aw run` first");
+  }
+  const baseURL = (workspace.server_url || "").trim();
+  const apiKey = (workspace.api_key || "").trim();
+  if (!baseURL || !apiKey) {
+    throw new Error("worktree workspace binding is missing server_url or api_key");
+  }
+  const identity = await readYAML(identityPath);
+  const alias = (workspace.identity_handle || workspace.alias || "").trim() || handleFromAddress((identity?.address || "").trim());
+  const projectSlug = (workspace.project_slug || "").trim();
+  const namespaceSlug = (workspace.namespace_slug || "").trim() || projectSlug;
+  const address = (identity?.address || "").trim() || deriveAddress(namespaceSlug, projectSlug, alias);
   return {
     baseURL,
-    apiKey: account.api_key,
-    did: account.did || "",
-    stableID: account.stable_id || "",
+    apiKey,
+    did: (identity?.did || "").trim() || (workspace.did || "").trim(),
+    stableID: (identity?.stable_id || "").trim() || (workspace.stable_id || "").trim(),
     address,
     alias,
     projectSlug
   };
 }
+function deriveAddress(namespaceSlug, projectSlug, alias) {
+  const handle = alias.trim();
+  if (!handle) return "";
+  const namespace = namespaceSlug.trim();
+  if (namespace) return `${namespace}/${handle}`;
+  const project = projectSlug.trim();
+  if (project) return `${project}/${handle}`;
+  return handle;
+}
+function handleFromAddress(address) {
+  const trimmed = address.trim();
+  if (!trimmed) return "";
+  const slash = trimmed.lastIndexOf("/");
+  if (slash < 0) return trimmed;
+  return trimmed.slice(slash + 1).trim();
+}
 async function readYAML(path) {
   try {
     const content = await readFile(path, "utf-8");
@@ -26099,14 +26098,19 @@ var SenderTrustManager = class {
   selfDid;
   namespace;
   metaCache = /* @__PURE__ */ new Map();
-  async normalizeTrust(store, verificationStatus, rawAddress, fromDID, fromStableID, toDID, rotationAnnouncement, replacementAnnouncement) {
+  async normalizeTrust(store, verificationStatus, rawAddress, fromDID, fromStableID, toDID, rotationAnnouncement, replacementAnnouncement, verificationAddress) {
     let status = this.checkRecipientBinding(verificationStatus, toDID);
     if (!status || !rawAddress.trim()) {
       return { status, stored: false };
     }
     const trustAddress = this.canonicalTrustAddress(rawAddress);
     const meta3 = await this.resolveAgentMeta(rawAddress);
-    status = await this.checkStableIdentityRegistry(status, trustAddress, fromDID, fromStableID);
+    status = await this.checkStableIdentityRegistry(
+      status,
+      (verificationAddress || rawAddress).trim(),
+      fromDID,
+      fromStableID
+    );
     return this.checkTOFUPinWithMeta(
       store,
       status,
@@ -26295,11 +26299,6 @@ var SenderTrustManager = class {
     }
     const cached2 = this.metaCache.get(trustAddress);
     if (cached2) return cached2;
-    const fallback = {
-      lifetime: "persistent",
-      custody: "self",
-      resolved: true
-    };
     try {
       const identity = await this.resolveIdentity(rawAddress);
       const meta3 = {
@@ -26311,10 +26310,7 @@ var SenderTrustManager = class {
       this.metaCache.set(trustAddress, meta3);
       return meta3;
     } catch {
-      if (rawAddress !== trustAddress) {
-        return { lifetime: "persistent", custody: "self", resolved: false };
-      }
-      return fallback;
+      return { lifetime: "persistent", custody: "self", resolved: false };
     }
   }
   async resolveIdentity(address) {
@@ -26413,7 +26409,7 @@ function escapeJSON3(s) {
 }
 
 // src/index.ts
-var PIN_STORE_PATH = join2(homedir2(), ".config", "aw", "known_agents.yaml");
+var PIN_STORE_PATH = join2(homedir(), ".config", "aw", "known_agents.yaml");
 var MAX_DISPATCHED_IDS = 2e3;
 async function loadPinStore() {
   try {
@@ -26487,16 +26483,17 @@ async function dispatchEvent(mcp, client, pinStore, trust, selfAlias, dispatched
       for (const msg of messages) {
         if (dispatched.has(msg.message_id)) continue;
         dispatched.add(msg.message_id);
-        const from = msg.from_address || msg.from_alias || "";
+        const from = senderDisplayAddress(msg.from_alias, msg.from_address);
         const tofu = await trust.normalizeTrust(
           pinStore,
           msg.verification_status,
-          from,
+          senderTrustAddress(msg.from_alias, msg.from_address),
           msg.from_did,
           msg.from_stable_id,
           msg.to_did,
           msg.rotation_announcement,
-          msg.replacement_announcement
+          msg.replacement_announcement,
+          msg.from_address || msg.from_alias || ""
         );
         msg.verification_status = tofu.status;
         if (tofu.stored) pinsDirty = true;
@@ -26528,16 +26525,17 @@ async function dispatchEvent(mcp, client, pinStore, trust, selfAlias, dispatched
         if (msg.from_agent === selfAlias) continue;
         if (dispatched.has(msg.message_id)) continue;
         dispatched.add(msg.message_id);
-        const from = msg.from_address || msg.from_agent;
+        const from = senderDisplayAddress(msg.from_agent, msg.from_address);
         const tofu = await trust.normalizeTrust(
           pinStore,
           msg.verification_status,
-          from,
+          senderTrustAddress(msg.from_agent, msg.from_address),
           msg.from_did,
           msg.from_stable_id,
           msg.to_did,
           msg.rotation_announcement,
-          msg.replacement_announcement
+          msg.replacement_announcement,
+          msg.from_address || msg.from_agent || ""
         );
         msg.verification_status = tofu.status;
         if (tofu.stored) pinsDirty = true;
@@ -26626,6 +26624,16 @@ async function dispatchEvent(mcp, client, pinStore, trust, selfAlias, dispatched
       break;
   }
 }
+function senderDisplayAddress(alias, address) {
+  const qualified = (address || "").trim();
+  if (qualified) return qualified;
+  return (alias || "").trim();
+}
+function senderTrustAddress(alias, address) {
+  const handle = (alias || "").trim();
+  if (handle) return handle;
+  return (address || "").trim();
+}
 function isDirectExecution(moduleURL) {
   const entry = process.argv[1];
   if (!entry) return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awebai/claude-channel",
-  "version": "0.2.2",
+  "version": "1.0.0",
   "type": "module",
   "main": "./dist/index.js",
   "bin": "./dist/index.js",