@outputai/cli 0.1.6 → 0.1.7-dev.1a80bf4.0

package/dist/services/credentials_configurator.d.ts

@@ -0,0 +1 @@
+export declare function configureCredentials(projectPath: string, skipPrompt?: boolean): Promise<boolean>;

package/dist/services/credentials_configurator.js

@@ -0,0 +1,68 @@
+import { password, confirm } from '@inquirer/prompts';
+import fs from 'node:fs';
+import path from 'node:path';
+import { ux } from '@oclif/core';
+import { load as parseYaml, dump as stringifyYaml } from 'js-yaml';
+import { UserCancelledError } from '#types/errors.js';
+import { getErrorMessage } from '#utils/error_utils.js';
+import { writeEncryptedAtPath } from './credentials_service.js';
+const FILL_MARKER = '<FILL_ME_OUT>';
+const CREDENTIALS_TEMPLATE = path.join('config', 'credentials.yml.template');
+const findSecretFields = (obj, prefix = []) => Object.entries(obj).flatMap(([key, value]) => {
+    const fieldPath = [...prefix, key];
+    if (value === FILL_MARKER) {
+        return [{ path: fieldPath, label: fieldPath.join('.') }];
+    }
+    if (typeof value === 'object' && value !== null) {
+        return findSecretFields(value, fieldPath);
+    }
+    return [];
+});
+const setAtPath = (obj, [head, ...tail], value) => {
+    if (tail.length === 0) {
+        obj[head] = value;
+    }
+    else {
+        setAtPath(obj[head], tail, value);
+    }
+};
+export async function configureCredentials(projectPath, skipPrompt = false) {
+    try {
+        const templatePath = path.join(projectPath, CREDENTIALS_TEMPLATE);
+        if (!fs.existsSync(templatePath)) {
+            return false;
+        }
+        if (skipPrompt) {
+            return false;
+        }
+        const shouldConfigure = await confirm({
+            message: 'Would you like to configure API credentials now?',
+            default: true
+        });
+        if (!shouldConfigure) {
+            return false;
+        }
+        const templateContent = fs.readFileSync(templatePath, 'utf-8');
+        const parsed = parseYaml(templateContent);
+        const secretFields = findSecretFields(parsed);
+        if (secretFields.length === 0) {
+            return false;
+        }
+        for (const field of secretFields) {
+            const value = await password({
+                message: `${field.label} (secret):`,
+                mask: true
+            });
+            setAtPath(parsed, field.path, value || '');
+        }
+        writeEncryptedAtPath(projectPath, stringifyYaml(parsed));
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'ExitPromptError') {
+            throw new UserCancelledError();
+        }
+        ux.warn(`Failed to configure credentials: ${getErrorMessage(error)}`);
+        return false;
+    }
+}

package/dist/services/credentials_service.d.ts

@@ -10,3 +10,9 @@ export declare const initCredentials: (environment: CredentialsEnvironment, work
     keyPath: string;
     credPath: string;
 };
+export declare const initCredentialsAtPath: (projectPath: string) => {
+    keyPath: string;
+    credPath: string;
+};
+export declare const readKeyAtPath: (projectPath: string) => string;
+export declare const writeEncryptedAtPath: (projectPath: string, plaintext: string) => void;

package/dist/services/credentials_service.js

@@ -62,3 +62,26 @@ export const initCredentials = (environment, workflow) => {
     fs.writeFileSync(credPath, encrypt(template, key), 'utf8');
     return { keyPath, credPath };
 };
+export const initCredentialsAtPath = (projectPath) => {
+    const credPath = resolveCredPath(projectPath);
+    const keyPath = resolveKPath(projectPath);
+    fs.mkdirSync(path.dirname(keyPath), { recursive: true });
+    fs.mkdirSync(path.dirname(credPath), { recursive: true });
+    const key = generateKey();
+    fs.writeFileSync(keyPath, key, { mode: 0o600 });
+    const template = stringifyYaml({
+        anthropic: { api_key: '<FILL_ME_OUT>' },
+        openai: { api_key: '<FILL_ME_OUT>' }
+    });
+    fs.writeFileSync(credPath, encrypt(template, key), 'utf8');
+    return { keyPath, credPath };
+};
+export const readKeyAtPath = (projectPath) => {
+    const keyPath = resolveKPath(projectPath);
+    return fs.readFileSync(keyPath, 'utf8').trim();
+};
+export const writeEncryptedAtPath = (projectPath, plaintext) => {
+    const key = readKeyAtPath(projectPath);
+    const credPath = resolveCredPath(projectPath);
+    fs.writeFileSync(credPath, encrypt(plaintext, key), 'utf8');
+};

package/dist/services/env_configurator.js

@@ -8,7 +8,7 @@ const COMMENT_LINE = /^\s*#/;
 const COMMENTED_VAR = /^\s*#\s*([A-Z_][A-Z0-9_]*)\s*=\s*(.*)$/;
 const ACTIVE_VAR = /^\s*([A-Z_][A-Z0-9_]*)\s*=\s*(.*)$/;
 const VAR_IN_COMMENT = /^\s*#\s*[A-Z_]+=/;
-const SECRET_MARKER = '<SECRET>';
+const SECRET_MARKER = '<FILL_ME_OUT>';
 function extractDescription(commentLine) {
     return commentLine.replace(/^\s*#\s*/, '').trim();
 }

package/dist/services/env_configurator.spec.js

@@ -29,7 +29,7 @@ describe('configureEnvironmentVariables', () => {
         }
     });
     it('should copy .env.example to .env when skipPrompt is true', async () => {
-        const envExampleContent = 'API_KEY=<SECRET>\nDATABASE_URL=localhost';
+        const envExampleContent = 'API_KEY=<FILL_ME_OUT>\nDATABASE_URL=localhost';
         await fs.writeFile(testState.envExamplePath, envExampleContent);
         const result = await configureEnvironmentVariables(testState.tempDir, true);
         expect(result).toBe(false);
@@ -182,7 +182,7 @@ EMPTY_KEY=`);
         vi.mocked(confirm).mockResolvedValue(true);
         vi.mocked(password).mockResolvedValueOnce('my-secret-api-key');
         await fs.writeFile(testState.envExamplePath, `# API Key
-ANTHROPIC_API_KEY=<SECRET>`);
+ANTHROPIC_API_KEY=<FILL_ME_OUT>`);
         const result = await configureEnvironmentVariables(testState.tempDir, false);
         expect(result).toBe(true);
         expect(vi.mocked(password)).toHaveBeenCalledTimes(1);

package/dist/services/messages.d.ts

@@ -2,7 +2,7 @@
  * Success and informational messages for project initialization
  */
 export declare const getEjectSuccessMessage: (destPath: string, outputFile: string, binName: string) => string;
-export declare const getProjectSuccessMessage: (folderName: string, installSuccess: boolean, envConfigured?: boolean) => string;
+export declare const getProjectSuccessMessage: (folderName: string, installSuccess: boolean, credentialsConfigured?: boolean) => string;
 export declare const getWorkflowGenerateSuccessMessage: (workflowName: string, targetDir: string, filesCreated: string[]) => string;
 export declare const getDevSuccessMessage: (services: Array<{
     name: string;

package/dist/services/messages.js

@@ -147,7 +147,7 @@ ${ux.colorize('dim', '💡 Tip: Test your changes with ')}${formatCommand('docke
 ${ux.colorize('green', ux.colorize('bold', 'Happy customizing! 🛠️'))}
 `;
 };
-export const getProjectSuccessMessage = (folderName, installSuccess, envConfigured = false) => {
+export const getProjectSuccessMessage = (folderName, installSuccess, credentialsConfigured = false) => {
     const divider = ux.colorize('dim', '─'.repeat(80));
     const bulletPoint = ux.colorize('green', '▸');
     // Build the next steps array with proper formatting
@@ -164,11 +164,11 @@ export const getProjectSuccessMessage = (folderName, installSuccess, envConfigur
             note: 'Required before running workflows'
         });
     }
-    if (!envConfigured) {
+    if (!credentialsConfigured) {
         steps.push({
-            step: 'Configure environment variables',
-            command: 'cp .env.example .env',
-            note: 'Copy .env.example to .env and add your API keys'
+            step: 'Add your API credentials',
+            command: 'npx output credentials edit',
+            note: 'Learn more: https://docs.output.ai/packages/credentials'
         });
     }
     steps.push({
@@ -229,6 +229,9 @@ ${divider}
 ${ux.colorize('dim', '💡 Tip: Use ')}${formatCommand('npx output workflow plan')}${ux.colorize('dim', ' to design your first custom workflow')}
 ${ux.colorize('dim', '         with AI assistance.')}
 
+${ux.colorize('dim', '🔑 Secrets: Use ')}${formatCommand('npx output credentials show|get|edit')}
+${ux.colorize('dim', '         to manage your project secrets.')}
+
 ${ux.colorize('green', ux.colorize('bold', 'Happy building with Output! 🚀'))}
 `;
 };

package/dist/services/project_scaffold.js

@@ -1,6 +1,7 @@
 import { input, confirm } from '@inquirer/prompts';
 import { ux } from '@oclif/core';
 import { kebabCase, pascalCase } from 'change-case';
+import fs from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { FolderAlreadyExistsError, UserCancelledError, DirectoryCreationError } from '#types/errors.js';
@@ -10,7 +11,8 @@ import { getFrameworkVersion } from '#utils/framework_version.js';
 import { getErrorMessage, getErrorCode } from '#utils/error_utils.js';
 import { isDockerInstalled } from '#services/docker.js';
 import { isClaudeCliAvailable } from '#utils/claude.js';
-import { configureEnvironmentVariables } from './env_configurator.js';
+import { initCredentialsAtPath } from './credentials_service.js';
+import { configureCredentials } from './credentials_configurator.js';
 import { getTemplateFiles, processTemplateFile } from './template_processor.js';
 import { initializeAgentConfig } from './coding_agents.js';
 import { getProjectSuccessMessage } from './messages.js';
@@ -105,6 +107,12 @@ async function scaffoldProjectFiles(projectPath, projectName, description) {
     await Promise.all(templateFiles.map(templateFile => processTemplateFile(templateFile, projectPath, templateVars)));
     return templateFiles.map(f => f.outputName);
 }
+const CREDENTIALS_TEMPLATE_CONTENT = 'anthropic:\n  api_key: "<FILL_ME_OUT>"\nopenai:\n  api_key: "<FILL_ME_OUT>"\n';
+async function createCredentialsTemplate(projectPath) {
+    const filePath = path.join(projectPath, 'config', 'credentials.yml.template');
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, CREDENTIALS_TEMPLATE_CONTENT, 'utf-8');
+}
 async function executeNpmInstall(projectPath) {
     await executeCommand('npm', ['install'], projectPath);
 }
@@ -192,13 +200,18 @@ export async function runInit(skipEnv = false, folderName) {
         ux.stdout(`Created project folder: ${config.folderName}`);
         const filesCreated = await scaffoldProjectFiles(config.projectPath, config.projectName, config.description);
         ux.stdout(`Created ${filesCreated.length} project files`);
-        const envConfigured = await configureEnvironmentVariables(config.projectPath, skipEnv);
-        if (envConfigured) {
-            ux.stdout('Environment variables configured in .env');
+        await createCredentialsTemplate(config.projectPath);
+        initCredentialsAtPath(config.projectPath);
+        ux.stdout('Credentials initialized');
+        const credentialsConfigured = await configureCredentials(config.projectPath, skipEnv);
+        if (credentialsConfigured) {
+            ux.stdout('API credentials configured');
         }
+        // Copy .env.example to .env (no secrets - they live in credentials.yml.enc)
+        await fs.copyFile(path.join(config.projectPath, '.env.example'), path.join(config.projectPath, '.env'));
         await executeCommandWithMessages(() => initializeAgents(config.projectPath), 'Initializing agent system...', 'Agent system initialized');
         const installSuccess = await executeCommandWithMessages(() => executeNpmInstall(config.projectPath), 'Installing dependencies...', 'Dependencies installed');
-        const nextSteps = getProjectSuccessMessage(config.folderName, installSuccess, envConfigured);
+        const nextSteps = getProjectSuccessMessage(config.folderName, installSuccess, credentialsConfigured);
         ux.stdout('Project created successfully!');
         ux.stdout(nextSteps);
     }

package/dist/services/project_scaffold.spec.js

@@ -14,8 +14,18 @@ vi.mock('@inquirer/prompts', () => ({
 }));
 vi.mock('#utils/file_system.js');
 vi.mock('#utils/process.js');
-vi.mock('./env_configurator.js', () => ({
-    configureEnvironmentVariables: vi.fn().mockResolvedValue(false)
+vi.mock('./credentials_service.js', () => ({
+    initCredentialsAtPath: vi.fn()
+}));
+vi.mock('./credentials_configurator.js', () => ({
+    configureCredentials: vi.fn().mockResolvedValue(false)
+}));
+vi.mock('node:fs/promises', () => ({
+    default: {
+        mkdir: vi.fn().mockResolvedValue(undefined),
+        writeFile: vi.fn().mockResolvedValue(undefined),
+        copyFile: vi.fn().mockResolvedValue(undefined)
+    }
 }));
 vi.mock('./template_processor.js');
 vi.mock('./coding_agents.js');

package/dist/templates/project/.env.example.template

@@ -2,8 +2,8 @@
 DOCKER_SERVICE_NAME={{projectName}}
 
 # Configure if you plan to use Anthropic Models in your LLM prompts
-ANTHROPIC_API_KEY=<SECRET>
+ANTHROPIC_API_KEY=credential:anthropic.api_key
 
 # Configure if you plan to use OpenAI in your LLM prompts
-OPENAI_API_KEY=<SECRET>
+OPENAI_API_KEY=credential:openai.api_key
 

package/dist/templates/project/package.json.template

@@ -21,5 +21,8 @@
   },
   "engines": {
     "node": ">=24.3.0"
+  },
+  "output": {
+    "hookFiles": ["@outputai/credentials"]
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/cli",
-  "version": "0.1.6",
+  "version": "0.1.7-dev.1a80bf4.0",
   "description": "CLI for Output.ai workflow generation",
   "type": "module",
   "main": "dist/index.js",
@@ -33,9 +33,9 @@
     "log-update": "7.2.0",
     "semver": "7.7.4",
     "yaml": "^2.7.1",
-    "@outputai/credentials": "0.1.6",
-    "@outputai/evals": "0.1.6",
-    "@outputai/llm": "0.1.6"
+    "@outputai/llm": "0.1.7-dev.1a80bf4.0",
+    "@outputai/credentials": "0.1.7-dev.1a80bf4.0",
+    "@outputai/evals": "0.1.7-dev.1a80bf4.0"
   },
   "devDependencies": {
     "@types/cli-progress": "3.11.6",