@digitalpresence/cliclaw-auth 0.1.1 → 0.3.0

package/src/instance-store.ts

@@ -0,0 +1,136 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  rmSync,
+  readdirSync,
+  statSync,
+} from "fs";
+import { join } from "path";
+import { AgentStore } from "./agent-store.js";
+import { generateUniversalClaudeMd, generateContextMd } from "./claude-md-generator.js";
+import { MemoryStore } from "./memory-store.js";
+
+export class InstanceStore {
+  constructor(
+    private instancesDir: string,
+    private agentStore: AgentStore,
+  ) {}
+
+  private ensureDir(path: string): void {
+    if (!existsSync(path)) {
+      mkdirSync(path, { recursive: true });
+    }
+  }
+
+  private readFileOrEmpty(path: string): string {
+    try {
+      return readFileSync(path, "utf-8");
+    } catch {
+      return "";
+    }
+  }
+
+  /** Get the root path for an instance */
+  getInstancePath(agentName: string, userId: string): string {
+    return join(this.instancesDir, agentName, userId);
+  }
+
+  /** Get the workspace subdir (what gets mounted into Docker) */
+  getWorkspacePath(agentName: string, userId: string): string {
+    return join(this.getInstancePath(agentName, userId), "workspace");
+  }
+
+  /** Create a new instance by copying template files and generating CONTEXT.md */
+  createInstance(agentName: string, userId: string): string {
+    const config = this.agentStore.get(agentName);
+    if (!config) throw new Error(`Agent "${agentName}" not found`);
+
+    const instancePath = this.getInstancePath(agentName, userId);
+    this.ensureDir(instancePath);
+    this.ensureDir(join(instancePath, "workspace"));
+    this.ensureDir(join(instancePath, "memory"));
+    this.ensureDir(join(instancePath, "cron"));
+
+    // Read agent template files
+    const agentDir = this.agentStore.workspacePath(agentName);
+    const soul = this.readFileOrEmpty(join(agentDir, "SOUL.md"));
+    const role = this.readFileOrEmpty(join(agentDir, "ROLE.md"));
+
+    // Generate CONTEXT.md content
+    const memoryStore = new MemoryStore(join(instancePath, "memory"));
+    const memories = memoryStore.list();
+    const context = generateContextMd(config, memories);
+
+    // Generate unified CLAUDE.md with soul/role/context inlined
+    writeFileSync(
+      join(instancePath, "CLAUDE.md"),
+      generateUniversalClaudeMd({ soul, role, context }),
+      "utf-8",
+    );
+
+    return instancePath;
+  }
+
+  /** Re-copy template files and regenerate CONTEXT.md after agent config changes */
+  syncInstance(agentName: string, userId: string): void {
+    const config = this.agentStore.get(agentName);
+    if (!config) throw new Error(`Agent "${agentName}" not found`);
+
+    const instancePath = this.getInstancePath(agentName, userId);
+    if (!existsSync(instancePath)) {
+      this.createInstance(agentName, userId);
+      return;
+    }
+
+    // Read agent template files
+    const agentDir = this.agentStore.workspacePath(agentName);
+    const soul = this.readFileOrEmpty(join(agentDir, "SOUL.md"));
+    const role = this.readFileOrEmpty(join(agentDir, "ROLE.md"));
+
+    // Regenerate unified CLAUDE.md with soul/role/context inlined
+    const memoryStore = new MemoryStore(join(instancePath, "memory"));
+    const memories = memoryStore.list();
+    const context = generateContextMd(config, memories);
+    writeFileSync(
+      join(instancePath, "CLAUDE.md"),
+      generateUniversalClaudeMd({ soul, role, context }),
+      "utf-8",
+    );
+  }
+
+  /** Delete an instance */
+  deleteInstance(agentName: string, userId: string): boolean {
+    const instancePath = this.getInstancePath(agentName, userId);
+    if (!existsSync(instancePath)) return false;
+    rmSync(instancePath, { recursive: true });
+    return true;
+  }
+
+  /** List all instances, optionally filtered by agent name */
+  listInstances(agentName?: string): Array<{ agentName: string; userId: string; path: string }> {
+    const results: Array<{ agentName: string; userId: string; path: string }> = [];
+
+    if (!existsSync(this.instancesDir)) return results;
+
+    const agentDirs = agentName ? [agentName] : readdirSync(this.instancesDir).filter((entry) => {
+      const entryPath = join(this.instancesDir, entry);
+      return statSync(entryPath).isDirectory();
+    });
+
+    for (const agent of agentDirs) {
+      const agentPath = join(this.instancesDir, agent);
+      if (!existsSync(agentPath)) continue;
+
+      for (const userId of readdirSync(agentPath)) {
+        const userPath = join(agentPath, userId);
+        if (statSync(userPath).isDirectory()) {
+          results.push({ agentName: agent, userId, path: userPath });
+        }
+      }
+    }
+
+    return results;
+  }
+}

package/src/integration-registry.ts

@@ -1,23 +1,58 @@
 export interface IntegrationDef {
   id: string;
   displayName: string;
+  provider: string;
   scopes: string[];
 }
 
+export interface ProviderConfig {
+  authUrl: string;
+  tokenUrl: string;
+  userInfoUrl: string;
+  clientIdEnv: string;
+  clientSecretEnv: string;
+  extraScopes: string[];
+  extraAuthParams: Record<string, string>;
+}
+
+export const PROVIDERS: Record<string, ProviderConfig> = {
+  google: {
+    authUrl: "https://accounts.google.com/o/oauth2/v2/auth",
+    tokenUrl: "https://oauth2.googleapis.com/token",
+    userInfoUrl: "https://www.googleapis.com/oauth2/v2/userinfo",
+    clientIdEnv: "GOOGLE_CLIENT_ID",
+    clientSecretEnv: "GOOGLE_CLIENT_SECRET",
+    extraScopes: ["openid", "email", "profile"],
+    extraAuthParams: { access_type: "offline", prompt: "consent" },
+  },
+  github: {
+    authUrl: "https://github.com/login/oauth/authorize",
+    tokenUrl: "https://github.com/login/oauth/access_token",
+    userInfoUrl: "https://api.github.com/user",
+    clientIdEnv: "GITHUB_CLIENT_ID",
+    clientSecretEnv: "GITHUB_CLIENT_SECRET",
+    extraScopes: [],
+    extraAuthParams: {},
+  },
+};
+
 export const INTEGRATIONS: Record<string, IntegrationDef> = {
   gmail: {
     id: "gmail",
     displayName: "Gmail",
+    provider: "google",
     scopes: ["https://www.googleapis.com/auth/gmail.modify"],
   },
   gdrive: {
     id: "gdrive",
     displayName: "Google Drive",
+    provider: "google",
     scopes: ["https://www.googleapis.com/auth/drive"],
   },
   gsheets: {
     id: "gsheets",
     displayName: "Google Sheets",
+    provider: "google",
     scopes: [
       "https://www.googleapis.com/auth/spreadsheets",
       "https://www.googleapis.com/auth/drive",
@@ -26,6 +61,7 @@ export const INTEGRATIONS: Record<string, IntegrationDef> = {
   gslides: {
     id: "gslides",
     displayName: "Google Slides",
+    provider: "google",
     scopes: [
       "https://www.googleapis.com/auth/presentations",
       "https://www.googleapis.com/auth/drive.file",
@@ -34,15 +70,23 @@ export const INTEGRATIONS: Record<string, IntegrationDef> = {
   calendar: {
     id: "calendar",
     displayName: "Google Calendar",
+    provider: "google",
     scopes: ["https://www.googleapis.com/auth/calendar"],
   },
   forms: {
     id: "forms",
     displayName: "Google Forms",
+    provider: "google",
     scopes: [
       "https://www.googleapis.com/auth/forms.body",
       "https://www.googleapis.com/auth/forms.responses.readonly",
       "https://www.googleapis.com/auth/drive.metadata.readonly",
     ],
   },
+  github: {
+    id: "github",
+    displayName: "GitHub",
+    provider: "github",
+    scopes: ["repo", "read:user", "user:email"],
+  },
 };

package/src/scoped-client-manager.ts

@@ -1,7 +1,6 @@
 import { google } from "googleapis";
 import { OAuthClientManager } from "./oauth-client-manager.js";
 import { TokenStore } from "./token-store.js";
-import type { AgentPermission } from "./agent-store.js";
 
 type OAuth2Client = InstanceType<typeof google.auth.OAuth2>;
 
@@ -23,18 +22,16 @@ function parseAccountKey(key: string): { integration: string; account: string }
 export class ScopedClientManager {
   constructor(
     private inner: OAuthClientManager,
-    private permissions: AgentPermission[],
+    private integrations: string[],
   ) {}
 
-  private hasPermission(integration: string, _account: string): boolean {
-    return this.permissions.some(
-      (p) => p.integration === integration,
-    );
+  private hasPermission(integration: string): boolean {
+    return this.integrations.includes(integration);
   }
 
   getClient(accountKey: string): OAuth2Client {
     const { integration, account } = parseAccountKey(accountKey);
-    if (!this.hasPermission(integration, account)) {
+    if (!this.hasPermission(integration)) {
       throw new PermissionDeniedError(integration, account);
     }
     return this.inner.getClient(accountKey);
@@ -42,8 +39,8 @@ export class ScopedClientManager {
 
   listAccounts(): string[] {
     return this.inner.listAccounts().filter((key) => {
-      const { integration, account } = parseAccountKey(key);
-      return this.hasPermission(integration, account);
+      const { integration } = parseAccountKey(key);
+      return this.hasPermission(integration);
     });
   }
 
@@ -57,7 +54,7 @@ export class ScopedClientManager {
 
   setCredentials(account: string, tokens: Parameters<OAuth2Client["setCredentials"]>[0]): OAuth2Client {
     const { integration, account: acct } = parseAccountKey(account);
-    if (!this.hasPermission(integration, acct)) {
+    if (!this.hasPermission(integration)) {
       throw new PermissionDeniedError(integration, acct);
     }
     return this.inner.setCredentials(account, tokens);

package/src/token-store.ts

@@ -1,9 +1,10 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname } from "path";
-import type { Credentials } from "google-auth-library";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type OAuthCredentials = Record<string, any>;
 
 interface TokenFile {
-  [account: string]: Credentials;
+  [account: string]: OAuthCredentials;
 }
 
 export class TokenStore {
@@ -28,7 +29,7 @@ export class TokenStore {
     writeFileSync(this.tokensPath, JSON.stringify(data, null, 2), "utf-8");
   }
 
-  get(account: string): Credentials | null {
+  get(account: string): OAuthCredentials | null {
     const data = this.load();
     if (data[account]) return data[account];
     // Fall back to integration:account key format (portal token injection)
@@ -41,7 +42,7 @@ export class TokenStore {
     return null;
   }
 
-  set(account: string, tokens: Credentials): void {
+  set(account: string, tokens: OAuthCredentials): void {
     const data = this.load();
     data[account] = tokens;
     this.save(data);