@rooaak/cli 0.1.0-beta.1 → 0.1.0-beta.2

package/dist/src/commands/init/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/init/index.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AA4XzD,wBAAsB,WAAW,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAgctF"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/init/index.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAgTzD,wBAAsB,WAAW,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CA8WtF"}

package/dist/src/commands/init/index.js

@@ -41,7 +41,7 @@ function noTtyUsageError(message, details = {}) {
         details,
     });
 }
-async function requireAdminTransport(ctx, r, argvApiKey) {
+async function requireInitTransport(ctx, r, argvApiKey) {
     const store = createProfileStore({ configPath: ctx.profileConfigPath });
     const cfgRes = store.readConfig();
     if (cfgRes.kind === "corrupt") {
@@ -55,19 +55,27 @@ async function requireAdminTransport(ctx, r, argvApiKey) {
         env: ctx.env.ROOAAK_BASE_URL,
         profile: profile?.baseUrl,
     });
-    async function validateAdminKey(candidate) {
+    async function validateInitKey(candidate) {
         const transport = createTransport({ baseUrl, apiKey: candidate, fetchFn: ctx.fetchFn });
-        const res = await transport.getJson("/api/v1/projects?limit=1");
+        const res = await transport.getJson("/api/v1/agents?limit=1");
         if (!res.ok) {
-            return { ok: false, http: { status: res.status, requestId: res.requestId, err: res.error } };
+            return { ok: false, status: res.status, requestId: res.requestId, err: res.error };
         }
         return { ok: true, transport, meta: { status: res.status, requestId: res.requestId } };
     }
     if (typeof argvApiKey === "string" && argvApiKey.length > 0) {
-        const v = await validateAdminKey(argvApiKey);
-        if (v.ok)
-            return { ok: true, transport: v.transport, baseUrl, adminApiKey: argvApiKey, requestMeta: v.meta };
-        const status = v.http?.status;
+        const v = await validateInitKey(argvApiKey);
+        if (v.ok) {
+            return {
+                ok: true,
+                transport: v.transport,
+                baseUrl,
+                apiKey: argvApiKey,
+                keySource: "argv",
+                requestMeta: v.meta,
+            };
+        }
+        const status = v.status;
         if (status === 401) {
             return {
                 ok: false,
@@ -75,7 +83,7 @@ async function requireAdminTransport(ctx, r, argvApiKey) {
                 err: normalizeInitError({
                     code: "auth.invalid_api_key",
                     message: "Invalid API key",
-                    meta: { status: v.http?.status, requestId: v.http?.requestId },
+                    meta: { status: v.status, requestId: v.requestId },
                 }),
             };
         }
@@ -84,21 +92,30 @@ async function requireAdminTransport(ctx, r, argvApiKey) {
                 ok: false,
                 exit: ExitCode.Permission,
                 err: normalizeInitError({
-                    code: "permission.admin_key_required",
-                    message: "Admin API key required to create/select projects.",
-                    details: { next: "Use an admin API key with scope admin:project (project_id must be NULL)." },
-                    meta: { status: v.http?.status, requestId: v.http?.requestId },
+                    code: "permission.forbidden",
+                    message: "API key lacks required scope: project:agent",
+                    details: { next: "Use a project API key with scope project:agent." },
+                    meta: { status: v.status, requestId: v.requestId },
                 }),
             };
         }
-        return { ok: false, exit: exitCodeForError(v.http?.err ?? normalizeInitError({ code: "server.error", message: "Server error" })), err: v.http?.err ?? normalizeInitError({ code: "server.error", message: "Server error" }) };
+        return { ok: false, exit: exitCodeForError(v.err), err: v.err };
     }
     if (profile?.apiKey) {
-        const v = await validateAdminKey(profile.apiKey);
-        if (v.ok)
-            return { ok: true, transport: v.transport, baseUrl, adminApiKey: profile.apiKey, requestMeta: v.meta };
-        const status = v.http?.status;
-        const err = v.http?.err ?? normalizeInitError({ code: "server.error", message: "Server error" });
+        const v = await validateInitKey(profile.apiKey);
+        if (v.ok) {
+            return {
+                ok: true,
+                transport: v.transport,
+                baseUrl,
+                apiKey: profile.apiKey,
+                keySource: "profile",
+                sourceProfileName: config?.currentProfile,
+                requestMeta: v.meta,
+            };
+        }
+        const status = v.status;
+        const err = v.err;
         if (ctx.flags.nonInteractive) {
             if (status === 401) {
                 return {
@@ -107,7 +124,7 @@ async function requireAdminTransport(ctx, r, argvApiKey) {
                     err: normalizeInitError({
                         code: "auth.invalid_api_key",
                         message: "Invalid API key",
-                        meta: { status: v.http?.status, requestId: v.http?.requestId },
+                        meta: { status: v.status, requestId: v.requestId },
                     }),
                 };
             }
@@ -116,23 +133,21 @@ async function requireAdminTransport(ctx, r, argvApiKey) {
                     ok: false,
                     exit: ExitCode.Permission,
                     err: normalizeInitError({
-                        code: "permission.admin_key_required",
-                        message: err.message || "Admin API key required to create/select projects.",
-                        details: {
-                            next: "Pass --api-key with an admin API key (scope admin:project), or switch to an admin profile.",
-                        },
-                        meta: { status: v.http?.status, requestId: v.http?.requestId },
+                        code: "permission.forbidden",
+                        message: "API key lacks required scope: project:agent",
+                        details: { next: "Use a project API key with scope project:agent." },
+                        meta: { status: v.status, requestId: v.requestId },
                     }),
                 };
             }
             return { ok: false, exit: exitCodeForError(err), err };
         }
-        // Interactive: allow recovery by prompting for an admin key on auth/permission failures.
+        // Interactive: allow recovery by prompting for another key on auth/permission failures.
         if (status === 401) {
-            r.warn("Current profile API key is invalid. You'll be prompted for an admin API key.");
+            r.warn("Current profile API key is invalid. You'll be prompted for an API key.");
         }
         else if (status === 403) {
-            r.warn("Current profile API key cannot manage projects. You'll be prompted for an admin API key.");
+            r.warn("Current profile API key cannot run init. You'll be prompted for a key with project:agent scope.");
         }
         else {
             // Network/transient failures won't be fixed by prompting.
@@ -156,107 +171,32 @@ async function requireAdminTransport(ctx, r, argvApiKey) {
             err: noTtyUsageError("Cannot prompt for API key because stdin is not a TTY. Re-run with --non-interactive and provide --api-key, or run `rooaak auth login --api-key ...` from an interactive terminal."),
         };
     }
-    // Interactive: prompt until valid admin key is provided.
+    // Interactive: prompt until a key that can run init is provided.
     while (true) {
-        const entered = await promptSecret({ stderr: ctx.stderr, stdin: ctx.stdin, stdinIsTTY: ctx.stdinIsTTY }, "Admin API key", { allowEmpty: false });
-        const v = await validateAdminKey(entered);
-        if (v.ok)
-            return { ok: true, transport: v.transport, baseUrl, adminApiKey: entered, requestMeta: v.meta };
-        const status = v.http?.status;
+        const entered = await promptSecret({ stderr: ctx.stderr, stdin: ctx.stdin, stdinIsTTY: ctx.stdinIsTTY }, "API key", { allowEmpty: false });
+        const v = await validateInitKey(entered);
+        if (v.ok) {
+            return {
+                ok: true,
+                transport: v.transport,
+                baseUrl,
+                apiKey: entered,
+                keySource: "prompt",
+                requestMeta: v.meta,
+            };
+        }
+        const status = v.status;
         if (status === 401) {
             r.error("Invalid API key. Try again.");
             continue;
         }
         if (status === 403) {
-            r.error("That key cannot manage projects. Use an admin API key with scope admin:project.");
+            r.error("That key lacks required scope for init. Use a key with project:agent.");
             continue;
         }
-        r.error(v.http?.err.message ?? "Request failed. Try again.");
+        r.error(v.err.message ?? "Request failed. Try again.");
     }
 }
-async function findProjectsByExactName(adminTransport, projectName) {
-    const matches = [];
-    let cursor = null;
-    let meta = null;
-    while (true) {
-        const qs = new URLSearchParams();
-        qs.set("limit", "500");
-        if (cursor)
-            qs.set("cursor", cursor);
-        const httpRes = await adminTransport.getJson(`/api/v1/projects?${qs.toString()}`);
-        if (!httpRes.ok)
-            return { ok: false, err: httpRes.error };
-        meta = { status: httpRes.status, requestId: httpRes.requestId };
-        const items = Array.isArray(httpRes.data.items) ? httpRes.data.items : [];
-        for (const p of items) {
-            if (p.name === projectName)
-                matches.push(p);
-            if (matches.length >= 2) {
-                return { ok: true, matches, meta };
-            }
-        }
-        const next = httpRes.data.nextCursor ?? null;
-        if (!next)
-            return { ok: true, matches, meta };
-        cursor = next;
-    }
-}
-async function ensureProjectByName(input) {
-    const findRes = await findProjectsByExactName(input.adminTransport, input.projectName);
-    if (!findRes.ok)
-        return { ok: false, err: findRes.err };
-    const matches = findRes.matches;
-    if (matches.length === 1)
-        return { ok: true, project: matches[0], created: false, meta: findRes.meta };
-    if (matches.length > 1) {
-        return {
-            ok: false,
-            err: normalizeInitError({
-                code: "conflict.duplicate_project_name",
-                message: `Multiple projects named '${input.projectName}' exist.`,
-                details: { next: "Run `rooaak init` in interactive mode to select a project." },
-                meta: findRes.meta,
-            }),
-        };
-    }
-    const createRes = await input.adminTransport.requestJson({
-        method: "POST",
-        path: "/api/v1/projects",
-        body: { name: input.projectName },
-    });
-    if (createRes.ok) {
-        return { ok: true, project: { id: createRes.data.id, name: createRes.data.name }, created: true, meta: { status: createRes.status, requestId: createRes.requestId } };
-    }
-    // Best-effort recovery: if the create failed but the project exists now (race, duplicate name), select it.
-    const findAgain = await findProjectsByExactName(input.adminTransport, input.projectName);
-    if (findAgain.ok) {
-        const againMatches = findAgain.matches;
-        if (againMatches.length === 1)
-            return { ok: true, project: againMatches[0], created: false, meta: findAgain.meta };
-    }
-    return { ok: false, err: createRes.error };
-}
-async function createProjectApiKey(input) {
-    const httpRes = await input.adminTransport.requestJson({
-        method: "POST",
-        path: `/api/v1/projects/${input.projectId}/api-keys`,
-        body: { name: input.name },
-    });
-    if (!httpRes.ok)
-        return { ok: false, err: httpRes.error };
-    const key = isPlainObject(httpRes.data) && typeof httpRes.data.key === "string" ? httpRes.data.key : null;
-    if (!key) {
-        return {
-            ok: false,
-            err: normalizeInitError({
-                code: "server.invalid_response",
-                message: "Server returned an unexpected API key response.",
-                meta: { status: httpRes.status, requestId: httpRes.requestId },
-            }),
-        };
-    }
-    return { ok: true, apiKey: key, meta: { status: httpRes.status, requestId: httpRes.requestId } };
-}
 function writeProjectProfile(input) {
     const store = createProfileStore({ configPath: input.ctx.profileConfigPath });
     const existingRes = store.readConfig();
@@ -307,7 +247,7 @@ export async function initCommand(ctx, argv) {
     const r = createRenderer(ctx);
     const parsed = parseOptions(argv, [
         { name: "--help", takesValue: false },
-        { name: "--api-key", takesValue: true }, // admin key
+        { name: "--api-key", takesValue: true }, // must include project:agent
         { name: "--project-name", takesValue: true },
         { name: "--agent-name", takesValue: true },
         { name: "--test-message", takesValue: true },
@@ -347,14 +287,14 @@ export async function initCommand(ctx, argv) {
                 command: "init",
                 usage: "rooaak init [--api-key <key>] [--project-name <name>] [--agent-name <name>] [--test-message <text>] [--wait-timeout-ms <ms>] [--profile <name>] [--start|--no-start] [--json] [--non-interactive]",
                 flags: [
-                    { name: "--api-key <key>", description: "Admin API key (required when not logged in as admin)" },
-                    { name: "--project-name <name>", description: "Project name to create/select" },
+                    { name: "--api-key <key>", description: "Project API key (must include project:agent scope)" },
+                    { name: "--project-name <name>", description: "Optional project label for local profile naming/output" },
                     { name: "--agent-name <name>", description: "Agent name to create" },
                     { name: "--test-message <text>", description: "Message to send after creation" },
                     { name: "--wait-timeout-ms <ms>", description: "How long to wait for the first response (default 60000ms; overrides ROOAAK_SYNC_MESSAGE_TIMEOUT_MS)" },
                     { name: "--start", description: "Start the agent (default)" },
                     { name: "--no-start", description: "Skip starting the agent" },
-                    { name: "--profile <name>", description: "Profile name to save the created project API key under" },
+                    { name: "--profile <name>", description: "Profile name to save the API key under" },
                 ],
             }));
             return ExitCode.Success;
@@ -364,14 +304,14 @@ export async function initCommand(ctx, argv) {
             "  rooaak init [flags]",
             "",
             "Flags:",
-            "  --api-key <key>          Admin API key (required when not logged in as admin)",
-            "  --project-name <name>    Project name to create/select",
+            "  --api-key <key>          Project API key (must include project:agent scope)",
+            "  --project-name <name>    Optional project label for local profile naming/output",
             "  --agent-name <name>      Agent name to create",
             "  --test-message <text>    Message to send after creation",
             "  --wait-timeout-ms <ms>   How long to wait for the first response (default 60000ms; overrides ROOAAK_SYNC_MESSAGE_TIMEOUT_MS)",
             "  --start                  Start the agent (default)",
             "  --no-start               Skip starting the agent",
-            "  --profile <name>         Profile name to save created project API key under",
+            "  --profile <name>         Profile name to save API key under",
             "",
             "Global flags:",
             "  --json                   Machine output (single JSON object on stdout)",
@@ -411,24 +351,7 @@ export async function initCommand(ctx, argv) {
     else
         startAgent = await promptConfirm({ stderr: ctx.stderr, stdin: ctx.stdin, stdinIsTTY: ctx.stdinIsTTY }, "Start the agent now?", { defaultYes: true });
     if (!projectName) {
-        if (!interactive) {
-            const err = normalizeLocalUsageError("Missing required flag: --project-name");
-            if (ctx.flags.json)
-                r.json(toJsonErrorEnvelope(err));
-            else
-                r.error(err.message);
-            return ExitCode.Usage;
-        }
-        if (ctx.stdinIsTTY !== true) {
-            const err = noTtyUsageError("Cannot prompt for --project-name because stdin is not a TTY. Re-run with --non-interactive and provide --project-name.");
-            if (ctx.flags.json)
-                r.json(toJsonErrorEnvelope(err));
-            else
-                r.error(err.message);
-            return ExitCode.Usage;
-        }
-        projectName = await promptText({ stderr: ctx.stderr, stdin: ctx.stdin, stdinIsTTY: ctx.stdinIsTTY }, "Project name", { defaultValue: safeBasename(ctx.cwd) });
-        projectName = projectName.trim();
+        projectName = safeBasename(ctx.cwd);
     }
     if (!agentName) {
         if (!interactive) {
@@ -492,110 +415,42 @@ export async function initCommand(ctx, argv) {
         }
         waitTimeoutMs = Math.floor(n);
     }
-    const adminApiKey = typeof parsed.values["--api-key"] === "string" ? parsed.values["--api-key"] : undefined;
-    const adminRes = await requireAdminTransport(ctx, r, adminApiKey);
-    if (!adminRes.ok) {
+    const inputApiKey = typeof parsed.values["--api-key"] === "string" ? parsed.values["--api-key"] : undefined;
+    const initAuthRes = await requireInitTransport(ctx, r, inputApiKey);
+    if (!initAuthRes.ok) {
         if (ctx.flags.json)
-            r.json(toJsonErrorEnvelope(adminRes.err));
+            r.json(toJsonErrorEnvelope(initAuthRes.err));
         else
-            r.error(adminRes.err.message);
-        return adminRes.exit;
-    }
-    const { transport: adminTransport, baseUrl } = adminRes;
-    if (interactive) {
-        r.warn("This will create/select a project, generate a project API key, create an agent, and send a first message.");
+            r.error(initAuthRes.err.message);
+        return initAuthRes.exit;
     }
-    // Create/select project.
-    let projectRes;
+    const { baseUrl } = initAuthRes;
+    const project = { id: null, name: projectName, created: false };
+    let projectApiKey = initAuthRes.apiKey;
+    let profileName = initAuthRes.sourceProfileName ?? "default";
     if (interactive) {
-        const findRes = await findProjectsByExactName(adminTransport, projectName);
-        if (!findRes.ok) {
-            const err = findRes.err;
+        r.warn("Using your project API key. This will create an agent and send a first message.");
+    }
+    const shouldPersistProfile = initAuthRes.keySource !== "profile" || typeof flagProfileName === "string";
+    if (shouldPersistProfile) {
+        const writeRes = writeProjectProfile({
+            ctx,
+            r,
+            baseUrl,
+            apiKey: projectApiKey,
+            projectName: project.name,
+            profileName: typeof flagProfileName === "string" ? flagProfileName : undefined,
+        });
+        if (!writeRes.ok) {
+            const err = writeRes.err;
             if (ctx.flags.json)
                 r.json(toJsonErrorEnvelope(err));
             else
                 r.error(err.message);
-            return exitCodeForError(err);
-        }
-        if (findRes.matches.length === 1) {
-            const shouldPrompt = ctx.stdinIsTTY === true;
-            const useExisting = shouldPrompt
-                ? await promptConfirm({ stderr: ctx.stderr, stdin: ctx.stdin, stdinIsTTY: ctx.stdinIsTTY }, `Project '${projectName}' exists. Use it?`, { defaultYes: true })
-                : true;
-            if (useExisting) {
-                projectRes = { ok: true, project: findRes.matches[0], created: false, meta: findRes.meta };
-            }
-            else {
-                projectName = await promptText({ stderr: ctx.stderr, stdin: ctx.stdin, stdinIsTTY: ctx.stdinIsTTY }, "Project name", { defaultValue: `${projectName}-2` });
-                projectName = projectName.trim();
-                projectRes = await ensureProjectByName({ adminTransport, projectName });
-            }
+            return writeRes.exit;
         }
-        else if (findRes.matches.length > 1) {
-            projectRes = {
-                ok: false,
-                err: normalizeInitError({
-                    code: "conflict.duplicate_project_name",
-                    message: `Multiple projects named '${projectName}' exist.`,
-                    details: { next: "Specify a unique --project-name or clean up duplicates." },
-                    meta: findRes.meta,
-                }),
-            };
-        }
-        else {
-            projectRes = await ensureProjectByName({ adminTransport, projectName });
-        }
-    }
-    else {
-        projectRes = await ensureProjectByName({ adminTransport, projectName });
+        profileName = writeRes.profileName;
     }
-    if (!projectRes.ok) {
-        const err = projectRes.err;
-        if (ctx.flags.json)
-            r.json(toJsonErrorEnvelope(err));
-        else {
-            r.error(err.message);
-            if (err.code === "permission.forbidden" || err.code.startsWith("permission.")) {
-                r.warn("Project management requires an admin API key with scope admin:project.");
-            }
-        }
-        return exitCodeForError(err);
-    }
-    const project = projectRes.project;
-    // Create a project-scoped API key and store it locally.
-    const apiKeyRes = await createProjectApiKey({
-        adminTransport,
-        projectId: project.id,
-        name: "rooaak-cli-init",
-    });
-    if (!apiKeyRes.ok) {
-        const err = apiKeyRes.err;
-        if (ctx.flags.json)
-            r.json(toJsonErrorEnvelope(err));
-        else {
-            r.error(err.message);
-            r.warn("Creating project API keys requires admin:project (admin key) or project:api-keys (project key).");
-        }
-        return exitCodeForError(err);
-    }
-    const projectApiKey = apiKeyRes.apiKey;
-    const writeRes = writeProjectProfile({
-        ctx,
-        r,
-        baseUrl,
-        apiKey: projectApiKey,
-        projectName: project.name,
-        profileName: typeof flagProfileName === "string" ? flagProfileName : undefined,
-    });
-    if (!writeRes.ok) {
-        const err = writeRes.err;
-        if (ctx.flags.json)
-            r.json(toJsonErrorEnvelope(err));
-        else
-            r.error(err.message);
-        return writeRes.exit;
-    }
-    const profileName = writeRes.profileName;
     const projectTransport = createTransport({ baseUrl, apiKey: projectApiKey, fetchFn: ctx.fetchFn });
     // Create agent.
     const agentRes = await projectTransport.requestJson({
@@ -710,7 +565,7 @@ export async function initCommand(ctx, argv) {
     const output = {
         baseUrl,
         profile: profileName,
-        project: { id: project.id, name: project.name, created: projectRes.created },
+        project: { id: project.id, name: project.name, created: project.created },
         agent: { id: agent.id, name: agent.name, started: startAgent },
         message: {
             id: messageId,
@@ -727,7 +582,10 @@ export async function initCommand(ctx, argv) {
         r.json(toJsonOkEnvelope(output, meta));
         return ExitCode.Success;
     }
-    r.text(`Project: ${project.name} (${project.id})`);
+    if (project.id)
+        r.text(`Project: ${project.name} (${project.id})`);
+    else
+        r.text(`Project: ${project.name}`);
     r.text(`Profile saved: '${profileName}'`);
     r.text(`Agent: ${agent.name} (${agent.id})`);
     if (messageStatus === "responded") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rooaak/cli",
-  "version": "0.1.0-beta.1",
+  "version": "0.1.0-beta.2",
   "description": "Rooaak CLI (companion to the Rooaak SDK)",
   "private": false,
   "type": "module",