@zleap-ai/sag-cli 0.6.0 → 0.6.2

package/dist/cli.js

@@ -9,7 +9,7 @@ import { checkbox, confirm, input, select } from "@inquirer/prompts";
 // package.json
 var package_default = {
   name: "@zleap-ai/sag-cli",
-  version: "0.6.0",
+  version: "0.6.2",
   description: "Command-line client and diagnostics for SAG knowledge bases",
   type: "module",
   bin: {
@@ -2851,10 +2851,15 @@ var skillAccountSchema = z11.strictObject({
   user: z11.strictObject({ id: z11.string().min(1), name: z11.string().min(1) }),
   recentKnowledgeBase: recentKnowledgeBaseSchema.optional()
 });
+var skillLinkTokenSchema = z11.strictObject({
+  kind: z11.literal("open_link"),
+  token: z11.string().regex(/^zmp_[A-Za-z0-9_-]{32,}$/)
+});
+var skillAuthorizationSchema = z11.union([skillAccountSchema, skillLinkTokenSchema]);
 var skillAccountConfigSchema = z11.object({
   version: z11.literal(1),
   currentOrigin: z11.string().optional(),
-  accounts: z11.record(z11.string(), skillAccountSchema)
+  accounts: z11.record(z11.string(), skillAuthorizationSchema)
 }).passthrough();
 function configurationConflict(message, filePath) {
   return new CliError("CONFIG_CONFLICT", message, {
@@ -2912,6 +2917,21 @@ var SkillAccountConfigStore = class {
       await this.#saveUnlocked(config);
     });
   }
+  async saveLinkToken(origin, token) {
+    const normalizedOrigin = normalizeSkillOrigin(origin);
+    let authorization;
+    try {
+      authorization = skillLinkTokenSchema.parse({ kind: "open_link", token });
+    } catch {
+      throw configurationConflict("Open Link token is invalid", this.filePath);
+    }
+    await this.#withLock(async () => {
+      const config = await this.load();
+      config.accounts[normalizedOrigin] = authorization;
+      config.currentOrigin = normalizedOrigin;
+      await this.#saveUnlocked(config);
+    });
+  }
   async removeAccount(origin) {
     const normalizedOrigin = normalizeSkillOrigin(origin);
     await this.#withLock(async () => {
@@ -2932,6 +2952,10 @@ var SkillAccountConfigStore = class {
     });
   }
   async getAccount(origin) {
+    const authorization = (await this.load()).accounts[normalizeSkillOrigin(origin)];
+    return authorization && !("kind" in authorization) ? authorization : null;
+  }
+  async getAuthorization(origin) {
     return (await this.load()).accounts[normalizeSkillOrigin(origin)] ?? null;
   }
   async saveRecentKnowledgeBase(origin, knowledgeBase) {
@@ -2946,6 +2970,7 @@ var SkillAccountConfigStore = class {
           this.filePath
         );
       }
+      if ("kind" in account) return;
       config.accounts[normalizedOrigin] = {
         ...account,
         recentKnowledgeBase: validated
@@ -7431,8 +7456,19 @@ async function withFreshSkillAccount(runtime2, origin, operation) {
   );
   return operation(accessToken);
 }
+async function withSkillAuthorization(runtime2, origin, operation) {
+  const normalizedOrigin = normalizeSkillOrigin(origin);
+  const authorization = runtime2.config.getAuthorization ? await runtime2.config.getAuthorization(normalizedOrigin) : null;
+  if (authorization && "kind" in authorization) return operation(authorization.token);
+  return withFreshSkillAccount(runtime2, normalizedOrigin, operation);
+}
 async function logoutSkillAccount(runtime2, origin) {
   const normalizedOrigin = normalizeSkillOrigin(origin);
+  const authorization = runtime2.config.getAuthorization ? await runtime2.config.getAuthorization(normalizedOrigin) : null;
+  if (authorization && "kind" in authorization) {
+    await runtime2.config.removeAccount(normalizedOrigin);
+    return true;
+  }
   const account = await runtime2.config.getAccount(normalizedOrigin);
   if (!account) return false;
   await runtime2.client.logout(
@@ -7588,7 +7624,7 @@ async function remember(runtime2, origin, knowledgeBase) {
 }
 async function withSkillAccountKnowledgeClient(runtime2, origin, operation) {
   const normalizedOrigin = normalizeSkillOrigin(origin);
-  return withFreshSkillAccount(
+  return withSkillAuthorization(
     runtime2.auth,
     normalizedOrigin,
     (accessToken) => operation(runtime2.createClient({ accessToken, origin: normalizedOrigin }))
@@ -7812,6 +7848,16 @@ function httpError(status2, problemCode, problemData) {
       ...details
     });
   }
+  if (normalizedProblemCode === "open_link_token_invalid") {
+    return new SkillError(
+      "AUTH_REQUIRED",
+      "The Open Link token is no longer valid. Ask the link administrator for a current token.",
+      {
+        exitCode: exitCodes.authRequired,
+        ...details
+      }
+    );
+  }
   if (normalizedProblemCode === "document_title_conflict") {
     return new SkillError("DOCUMENT_TITLE_CONFLICT", "The document title conflicts", {
       exitCode: exitCodes.configConflict,
@@ -9036,32 +9082,65 @@ function addSkillCommands(program, dependencies2) {
       []
     );
     command.option("--origin <origin>", "Full SAG HTTP or HTTPS Origin");
-    command.action(async (options) => {
-      if (options.origin) {
-        const account = dependencies2.skillAccount;
-        if (!account) {
-          throw new CliError(
-            "DEPENDENCY_MISSING",
-            "SAG account configuration is unavailable",
-            { exitCode: exitCodes.dependencyMissing }
-          );
+    command.option(
+      "--link-token <token>",
+      "Open Link token; replaces the saved authorization for this Origin"
+    );
+    command.action(
+      async (options) => {
+        if (options.linkToken && !options.origin) {
+          throw new CliError("INVALID_ARGUMENT", "--link-token requires --origin", {
+            exitCode: exitCodes.invalidArgument
+          });
+        }
+        if (options.origin) {
+          const account = dependencies2.skillAccount;
+          if (!account) {
+            throw new CliError(
+              "DEPENDENCY_MISSING",
+              "SAG account configuration is unavailable",
+              { exitCode: exitCodes.dependencyMissing }
+            );
+          }
+          if (options.linkToken) {
+            await account.config.saveLinkToken(options.origin, options.linkToken);
+          } else {
+            await account.config.setCurrentOrigin(options.origin);
+          }
         }
-        await account.config.setCurrentOrigin(options.origin);
+        await executeSkillTargets(
+          program,
+          dependencies2,
+          installSkillTargets(skillInstallerRuntime(dependencies2), {
+            ...options.agent.length ? { agents: options.agent } : {},
+            yes: commandOptions2(program).yes ?? false,
+            update: name === "update"
+          })
+        );
       }
-      await executeSkillTargets(
-        program,
-        dependencies2,
-        installSkillTargets(skillInstallerRuntime(dependencies2), {
-          ...options.agent.length ? { agents: options.agent } : {},
-          yes: commandOptions2(program).yes ?? false,
-          update: name === "update"
-        })
-      );
-    });
+    );
   };
   addInstall("install", "Install SAG Knowledge for every detected Agent");
   addInstall("update", "Resolve the running @latest package and update managed Skills");
   const auth = skill.command("auth").description("Authorize one SAG account Origin");
+  auth.command("paste-token").description("Save an Open Link token for one SAG Origin").requiredOption("--origin <origin>", "Full SAG HTTP or HTTPS Origin").requiredOption("--token <token>", "Open Link token provided by an administrator").action(async (options) => {
+    const account = dependencies2.skillAccount;
+    if (!account) {
+      throw new CliError(
+        "DEPENDENCY_MISSING",
+        "SAG account configuration is unavailable",
+        {
+          exitCode: exitCodes.dependencyMissing
+        }
+      );
+    }
+    await account.config.saveLinkToken(options.origin, options.token);
+    emit(program, dependencies2, {
+      origin: normalizeSkillOrigin(options.origin),
+      authorized: true,
+      method: "open_link"
+    });
+  });
   auth.command("login").description("Open browser approval and authorize the current SAG account").option("--origin <origin>", "Full SAG HTTP or HTTPS Origin").action(async (options) => {
     const origin = await resolveSkillOrigin(dependencies2, options.origin, true);
     emit(
@@ -9072,11 +9151,21 @@ function addSkillCommands(program, dependencies2) {
   });
   auth.command("status").description("Inspect the saved SAG account authorization").option("--origin <origin>", "Full SAG HTTP or HTTPS Origin").action(async (options) => {
     const origin = await resolveSkillOrigin(dependencies2, options.origin);
-    const account = await skillAccountAuthRuntime(dependencies2).config.getAccount(origin);
+    const configured = dependencies2.skillAccount;
+    if (!configured) {
+      throw new CliError(
+        "DEPENDENCY_MISSING",
+        "SAG account configuration is unavailable",
+        {
+          exitCode: exitCodes.dependencyMissing
+        }
+      );
+    }
+    const authorization = await configured.config.getAuthorization(origin);
     emit(program, dependencies2, {
-      authenticated: Boolean(account),
+      authenticated: Boolean(authorization),
       origin,
-      ...account ? { user: account.user } : {}
+      ...authorization && "kind" in authorization ? { method: "open_link" } : authorization ? { method: "browser", user: authorization.user } : {}
     });
   });
   auth.command("logout").description("Revoke and remove the saved SAG account authorization").option("--origin <origin>", "Full SAG HTTP or HTTPS Origin").action(async (options) => {