@assistkick/create 1.9.0 → 1.11.0

package/templates/assistkick-product-system/packages/backend/src/services/project_workspace_service.ts

@@ -55,6 +55,15 @@ export class ProjectWorkspaceService {
     }
   };
 
+  /** Verify that git is installed and available on the system. Throws if not. */
+  verifyGitAvailable = async (): Promise<void> => {
+    try {
+      await this.claudeService.spawnCommand('git', ['--version'], this.workspacesDir);
+    } catch {
+      throw new Error('Git is required to create a project. Please install git and try again.');
+    }
+  };
+
   /** Initialize a new empty local git repository for a project. */
   initWorkspace = async (projectId: string): Promise<string> => {
     const wsPath = this.getWorkspacePath(projectId);
@@ -74,20 +83,31 @@ export class ProjectWorkspaceService {
     return wsPath;
   };
 
-  /** Clone a remote repository into the project workspace. */
+  /**
+   * Connect a remote repository using git remote add + git fetch.
+   * Replaces the old rm -rf + git clone pattern.
+   * If the workspace doesn't have a git repo yet, initializes one first.
+   */
   cloneRepo = async (projectId: string, cloneUrl: string): Promise<string> => {
     const wsPath = this.getWorkspacePath(projectId);
-    await this.ensureDir(this.workspacesDir);
+    await this.ensureDir(wsPath);
 
-    // If workspace already exists, remove it first
-    if (existsSync(wsPath)) {
-      this.log('WORKSPACE', `Removing existing workspace before clone: ${wsPath}`);
-      await this.claudeService.spawnCommand('rm', ['-rf', wsPath], this.workspacesDir);
+    // Ensure there's a local git repo
+    if (!existsSync(join(wsPath, '.git'))) {
+      await this.initWorkspace(projectId);
     }
 
-    this.log('WORKSPACE', `Cloning ${cloneUrl} into ${wsPath}`);
-    await this.claudeService.spawnCommand('git', ['clone', cloneUrl, wsPath], this.workspacesDir);
-    this.log('WORKSPACE', `Clone completed for project ${projectId}`);
+    // Add the remote (replace if it already exists)
+    try {
+      await this.claudeService.spawnCommand('git', ['remote', 'remove', 'origin'], wsPath);
+    } catch {
+      // No existing origin — that's fine
+    }
+
+    this.log('WORKSPACE', `Adding remote origin ${cloneUrl} for project ${projectId}`);
+    await this.claudeService.spawnCommand('git', ['remote', 'add', 'origin', cloneUrl], wsPath);
+    await this.claudeService.spawnCommand('git', ['fetch', 'origin'], wsPath);
+    this.log('WORKSPACE', `Remote added and fetched for project ${projectId}`);
     return wsPath;
   };
 
@@ -103,16 +123,16 @@ export class ProjectWorkspaceService {
       // Returns e.g. "origin/main" — strip the "origin/" prefix
       const branch = result.trim().replace(/^origin\//, '');
       if (branch) return branch;
-    } catch {
-      // Fallback: try to get current branch name
+    } catch (err: any) {
+      this.log('WORKSPACE', `symbolic-ref lookup failed (trying fallback): ${err.message}`);
     }
 
     try {
       const result = await this.claudeService.spawnCommand('git', ['branch', '--show-current'], wsPath);
       const branch = result.trim();
       if (branch) return branch;
-    } catch {
-      // Final fallback
+    } catch (err: any) {
+      this.log('WORKSPACE', `branch --show-current failed (using default 'main'): ${err.message}`);
     }
 
     return 'main';
@@ -135,7 +155,7 @@ export class ProjectWorkspaceService {
       this.log('WORKSPACE', `Pull completed for project ${projectId}`);
     } catch (err: any) {
       // Pull may fail if there's no remote or no upstream — that's OK for local-only repos
-      this.log('WORKSPACE', `Pull failed (non-fatal): ${err.message}`);
+      this.log('WORKSPACE', `Pull failed (non-fatal):`, err.stack || err.message);
     }
 
     if (token && repoFullName) {
@@ -192,21 +212,32 @@ export class ProjectWorkspaceService {
     }
   };
 
-  /** Clone a remote repository using SSH key authentication. */
+  /**
+   * Connect a remote repository using SSH key authentication.
+   * Uses git remote add + git fetch instead of rm -rf + git clone.
+   */
   cloneRepoSsh = async (projectId: string, sshCloneUrl: string, encryptedPrivateKey: string): Promise<string> => {
     const wsPath = this.getWorkspacePath(projectId);
-    await this.ensureDir(this.workspacesDir);
+    await this.ensureDir(wsPath);
 
-    if (existsSync(wsPath)) {
-      this.log('WORKSPACE', `Removing existing workspace before SSH clone: ${wsPath}`);
-      await this.claudeService.spawnCommand('rm', ['-rf', wsPath], this.workspacesDir);
+    // Ensure there's a local git repo
+    if (!existsSync(join(wsPath, '.git'))) {
+      await this.initWorkspace(projectId);
     }
 
-    this.log('WORKSPACE', `SSH cloning into ${wsPath}`);
+    // Add the remote (replace if it already exists)
+    try {
+      await this.claudeService.spawnCommand('git', ['remote', 'remove', 'origin'], wsPath);
+    } catch {
+      // No existing origin — that's fine
+    }
+
+    this.log('WORKSPACE', `SSH adding remote origin ${sshCloneUrl} for project ${projectId}`);
+    await this.claudeService.spawnCommand('git', ['remote', 'add', 'origin', sshCloneUrl], wsPath);
     await this.withSshKey(encryptedPrivateKey, () =>
-      this.claudeService.spawnCommand('git', ['clone', sshCloneUrl, wsPath], this.workspacesDir),
+      this.claudeService.spawnCommand('git', ['fetch', 'origin'], wsPath),
     );
-    this.log('WORKSPACE', `SSH clone completed for project ${projectId}`);
+    this.log('WORKSPACE', `SSH remote added and fetched for project ${projectId}`);
     return wsPath;
   };
 
@@ -222,7 +253,7 @@ export class ProjectWorkspaceService {
       );
       this.log('WORKSPACE', `SSH pull completed for project ${projectId}`);
     } catch (err: any) {
-      this.log('WORKSPACE', `SSH pull failed (non-fatal): ${err.message}`);
+      this.log('WORKSPACE', `SSH pull failed (non-fatal):`, err.stack || err.message);
     }
   };
 
@@ -255,7 +286,9 @@ export class ProjectWorkspaceService {
     try {
       const result = await this.claudeService.spawnCommand('git', ['branch', '--show-current'], wsPath);
       currentBranch = result.trim() || null;
-    } catch {}
+    } catch (err: any) {
+      this.log('WORKSPACE', `Failed to get current branch for ${projectId}: ${err.message}`);
+    }
 
     let remoteUrl: string | null = null;
     let hasRemote = false;
@@ -263,8 +296,250 @@ export class ProjectWorkspaceService {
       const result = await this.claudeService.spawnCommand('git', ['remote', 'get-url', 'origin'], wsPath);
       remoteUrl = result.trim() || null;
       hasRemote = !!remoteUrl;
-    } catch {}
+    } catch (err: any) {
+      this.log('WORKSPACE', `No remote origin for ${projectId}: ${err.message}`);
+    }
 
     return { hasWorkspace: true, hasRemote, currentBranch, remoteUrl };
   };
+
+  /** List all local and remote branches. */
+  listBranches = async (projectId: string): Promise<{
+    current: string;
+    local: string[];
+    remote: string[];
+  }> => {
+    const wsPath = this.getWorkspacePath(projectId);
+
+    // Get current branch
+    let current = 'main';
+    try {
+      const result = await this.claudeService.spawnCommand('git', ['branch', '--show-current'], wsPath);
+      current = result.trim() || 'main';
+    } catch {}
+
+    // Get local branches
+    const local: string[] = [];
+    try {
+      const result = await this.claudeService.spawnCommand('git', ['branch', '--format=%(refname:short)'], wsPath);
+      for (const line of result.trim().split('\n')) {
+        const name = line.trim();
+        if (name) local.push(name);
+      }
+    } catch {}
+
+    // Get remote branches
+    const remote: string[] = [];
+    try {
+      const result = await this.claudeService.spawnCommand('git', ['branch', '-r', '--format=%(refname:short)'], wsPath);
+      for (const line of result.trim().split('\n')) {
+        const name = line.trim();
+        // Skip HEAD pointer and empty lines
+        if (name && !name.endsWith('/HEAD')) remote.push(name);
+      }
+    } catch {}
+
+    return { current, local, remote };
+  };
+
+  /** Check if there are uncommitted changes in the workspace. */
+  hasUncommittedChanges = async (projectId: string): Promise<boolean> => {
+    const wsPath = this.getWorkspacePath(projectId);
+    try {
+      const result = await this.claudeService.spawnCommand('git', ['status', '--porcelain'], wsPath);
+      return result.trim().length > 0;
+    } catch {
+      return false;
+    }
+  };
+
+  /** Commit all current changes with a message. */
+  commitAll = async (projectId: string, message: string): Promise<void> => {
+    const wsPath = this.getWorkspacePath(projectId);
+    await this.claudeService.spawnCommand('git', ['add', '-A'], wsPath);
+    await this.claudeService.spawnCommand('git', ['commit', '-m', message], wsPath);
+    this.log('WORKSPACE', `Committed all changes for project ${projectId}`);
+  };
+
+  /** Checkout an existing branch. */
+  checkoutBranch = async (projectId: string, branchName: string): Promise<void> => {
+    const wsPath = this.getWorkspacePath(projectId);
+    // If it's a remote branch (e.g. origin/feature), check it out locally
+    if (branchName.includes('/')) {
+      const localName = branchName.replace(/^[^/]+\//, '');
+      await this.claudeService.spawnCommand('git', ['checkout', '-b', localName, branchName], wsPath);
+      this.log('WORKSPACE', `Checked out remote branch ${branchName} as ${localName} for project ${projectId}`);
+    } else {
+      await this.claudeService.spawnCommand('git', ['checkout', branchName], wsPath);
+      this.log('WORKSPACE', `Checked out branch ${branchName} for project ${projectId}`);
+    }
+  };
+
+  /** Create and checkout a new branch. */
+  createBranch = async (projectId: string, branchName: string): Promise<void> => {
+    const wsPath = this.getWorkspacePath(projectId);
+    await this.claudeService.spawnCommand('git', ['checkout', '-b', branchName], wsPath);
+    this.log('WORKSPACE', `Created and checked out new branch ${branchName} for project ${projectId}`);
+  };
+
+  /** List all configured remotes with their URLs. */
+  listRemotes = async (projectId: string): Promise<Array<{ name: string; url: string }>> => {
+    const wsPath = this.getWorkspacePath(projectId);
+    const remotes: Array<{ name: string; url: string }> = [];
+    try {
+      const result = await this.claudeService.spawnCommand('git', ['remote', '-v'], wsPath);
+      const seen = new Set<string>();
+      for (const line of result.trim().split('\n')) {
+        const match = line.match(/^(\S+)\s+(\S+)\s+\(fetch\)$/);
+        if (match && !seen.has(match[1])) {
+          seen.add(match[1]);
+          remotes.push({ name: match[1], url: match[2] });
+        }
+      }
+    } catch {
+      // No remotes
+    }
+    return remotes;
+  };
+
+  /** Add a new remote. */
+  addRemote = async (projectId: string, name: string, url: string): Promise<void> => {
+    const wsPath = this.getWorkspacePath(projectId);
+    await this.claudeService.spawnCommand('git', ['remote', 'add', name, url], wsPath);
+    this.log('WORKSPACE', `Added remote ${name} → ${url} for project ${projectId}`);
+  };
+
+  /** Fetch from a remote to update tracking branches. */
+  fetchRemote = async (projectId: string, remote: string = 'origin'): Promise<void> => {
+    const wsPath = this.getWorkspacePath(projectId);
+    this.log('WORKSPACE', `Fetching ${remote} for project ${projectId}`);
+    await this.claudeService.spawnCommand('git', ['fetch', remote], wsPath);
+  };
+
+  /** Fetch from a remote using SSH key authentication. */
+  fetchRemoteSsh = async (projectId: string, encryptedPrivateKey: string, remote: string = 'origin'): Promise<void> => {
+    const wsPath = this.getWorkspacePath(projectId);
+    this.log('WORKSPACE', `SSH fetching ${remote} for project ${projectId}`);
+    await this.withSshKey(encryptedPrivateKey, () =>
+      this.claudeService.spawnCommand('git', ['fetch', remote], wsPath),
+    );
+  };
+
+  /** Pull current branch from remote. */
+  pullBranch = async (projectId: string, token?: string, repoFullName?: string): Promise<void> => {
+    const wsPath = this.getWorkspacePath(projectId);
+    const branch = await this.getCurrentBranch(projectId);
+
+    if (token && repoFullName) {
+      const authUrl = `https://x-access-token:${token}@github.com/${repoFullName}.git`;
+      await this.claudeService.spawnCommand('git', ['remote', 'set-url', 'origin', authUrl], wsPath);
+    }
+
+    try {
+      this.log('WORKSPACE', `Pulling ${branch} for project ${projectId}`);
+      await this.claudeService.spawnCommand('git', ['pull', 'origin', branch], wsPath);
+    } finally {
+      if (token && repoFullName) {
+        await this.claudeService.spawnCommand(
+          'git', ['remote', 'set-url', 'origin', `https://github.com/${repoFullName}.git`], wsPath,
+        ).catch(() => {});
+      }
+    }
+  };
+
+  /** Pull current branch from remote using SSH. */
+  pullBranchSsh = async (projectId: string, encryptedPrivateKey: string): Promise<void> => {
+    const wsPath = this.getWorkspacePath(projectId);
+    const branch = await this.getCurrentBranch(projectId);
+
+    this.log('WORKSPACE', `SSH pulling ${branch} for project ${projectId}`);
+    await this.withSshKey(encryptedPrivateKey, () =>
+      this.claudeService.spawnCommand('git', ['pull', 'origin', branch], wsPath),
+    );
+  };
+
+  /** Push current branch to remote. */
+  pushBranch = async (projectId: string, token?: string, repoFullName?: string): Promise<void> => {
+    const wsPath = this.getWorkspacePath(projectId);
+    const branch = await this.getCurrentBranch(projectId);
+
+    if (token && repoFullName) {
+      const authUrl = `https://x-access-token:${token}@github.com/${repoFullName}.git`;
+      await this.claudeService.spawnCommand('git', ['remote', 'set-url', 'origin', authUrl], wsPath);
+    }
+
+    try {
+      this.log('WORKSPACE', `Pushing ${branch} for project ${projectId}`);
+      await this.claudeService.spawnCommand('git', ['push', '-u', 'origin', branch], wsPath);
+    } finally {
+      if (token && repoFullName) {
+        await this.claudeService.spawnCommand(
+          'git', ['remote', 'set-url', 'origin', `https://github.com/${repoFullName}.git`], wsPath,
+        ).catch(() => {});
+      }
+    }
+  };
+
+  /** Push current branch to remote using SSH. */
+  pushBranchSsh = async (projectId: string, encryptedPrivateKey: string): Promise<void> => {
+    const wsPath = this.getWorkspacePath(projectId);
+    const branch = await this.getCurrentBranch(projectId);
+
+    this.log('WORKSPACE', `SSH pushing ${branch} for project ${projectId}`);
+    await this.withSshKey(encryptedPrivateKey, () =>
+      this.claudeService.spawnCommand('git', ['push', '-u', 'origin', branch], wsPath),
+    );
+  };
+
+  /** Get the current branch name. */
+  getCurrentBranch = async (projectId: string): Promise<string> => {
+    const wsPath = this.getWorkspacePath(projectId);
+    try {
+      const result = await this.claudeService.spawnCommand('git', ['branch', '--show-current'], wsPath);
+      return result.trim() || 'main';
+    } catch {
+      return 'main';
+    }
+  };
+
+  /** Get ahead/behind counts relative to the remote tracking branch. */
+  getAheadBehind = async (projectId: string): Promise<{ ahead: number; behind: number }> => {
+    const wsPath = this.getWorkspacePath(projectId);
+    try {
+      const branch = await this.getCurrentBranch(projectId);
+      const result = await this.claudeService.spawnCommand(
+        'git', ['rev-list', '--left-right', '--count', `${branch}...origin/${branch}`], wsPath,
+      );
+      const parts = result.trim().split(/\s+/);
+      return { ahead: parseInt(parts[0], 10) || 0, behind: parseInt(parts[1], 10) || 0 };
+    } catch {
+      return { ahead: 0, behind: 0 };
+    }
+  };
+
+  /** Check if the workspace has only the initial empty commit (auto-init). */
+  hasOnlyInitialCommit = async (projectId: string): Promise<boolean> => {
+    const wsPath = this.getWorkspacePath(projectId);
+    try {
+      const result = await this.claudeService.spawnCommand('git', ['rev-list', '--count', 'HEAD'], wsPath);
+      const count = parseInt(result.trim(), 10);
+      return count <= 1;
+    } catch {
+      return true;
+    }
+  };
+
+  /** Reset current branch to match a remote branch. Used when pulling from a populated remote. */
+  resetToRemoteBranch = async (projectId: string, remoteBranch: string = 'origin/main'): Promise<void> => {
+    const wsPath = this.getWorkspacePath(projectId);
+    this.log('WORKSPACE', `Resetting to ${remoteBranch} for project ${projectId}`);
+    await this.claudeService.spawnCommand('git', ['reset', '--hard', remoteBranch], wsPath);
+  };
+
+  /** Delete a local branch. */
+  deleteBranch = async (projectId: string, branchName: string): Promise<void> => {
+    const wsPath = this.getWorkspacePath(projectId);
+    await this.claudeService.spawnCommand('git', ['branch', '-D', branchName], wsPath);
+    this.log('WORKSPACE', `Deleted branch ${branchName} for project ${projectId}`);
+  };
 }

package/templates/assistkick-product-system/packages/backend/src/services/pty_session_manager.test.ts

@@ -157,6 +157,50 @@ describe('PtySessionManager', () => {
     });
   });
 
+  describe('dual session types', () => {
+    it('creates a claude session by default', async () => {
+      const session = await manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24);
+      assert.equal(session.sessionType, 'claude');
+
+      const [cmd] = spawnMock.mock.calls[0].arguments as [string, string[]];
+      assert.equal(cmd, 'claude');
+    });
+
+    it('creates a claude session when explicitly requested', async () => {
+      const session = await manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24, 'claude');
+      assert.equal(session.sessionType, 'claude');
+
+      const [cmd, args] = spawnMock.mock.calls[0].arguments as [string, string[]];
+      assert.equal(cmd, 'claude');
+      assert.ok(args.includes('--session-id'));
+    });
+
+    it('creates a terminal session that spawns /bin/bash', async () => {
+      const session = await manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24, 'terminal');
+      assert.equal(session.sessionType, 'terminal');
+
+      const [cmd, args] = spawnMock.mock.calls[0].arguments as [string, string[]];
+      assert.equal(cmd, '/bin/bash');
+      assert.deepEqual(args, []);
+    });
+
+    it('terminal session does not include claude flags', async () => {
+      await manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24, 'terminal');
+
+      const [, args] = spawnMock.mock.calls[0].arguments as [string, string[]];
+      assert.ok(!args.includes('--dangerously-skip-permissions'));
+      assert.ok(!args.includes('--append-system-prompt'));
+      assert.ok(!args.includes('--session-id'));
+    });
+
+    it('persists sessionType in the DB record', async () => {
+      await manager.createSession(PROJECT_ID, PROJECT_NAME, 80, 24, 'terminal');
+
+      const dbRow = mockDb._rows[0];
+      assert.equal(dbRow.sessionType, 'terminal');
+    });
+  });
+
   describe('formatSessionName', () => {
     it('formats session name as ProjectName - DD/MM/YY - HH:MM', () => {
       const date = new Date(2026, 2, 6, 14, 30); // 2026-03-06 14:30

package/templates/assistkick-product-system/packages/backend/src/services/pty_session_manager.ts

@@ -31,12 +31,15 @@ interface LivePty {
   rows: number;
 }
 
+export type SessionType = 'claude' | 'terminal';
+
 export interface SessionInfo {
   id: string;
   claudeSessionId: string;
   name: string;
   projectId: string;
   projectName: string;
+  sessionType: SessionType;
   state: 'suspended' | 'running';
   createdAt: string;
   lastUsedAt: string;
@@ -82,6 +85,7 @@ export class PtySessionManager {
       name: r.name,
       projectId: r.projectId,
       projectName: r.projectName,
+      sessionType: (r.sessionType || 'claude') as SessionType,
       state: this.live.has(r.id) ? 'running' as const : 'suspended' as const,
       createdAt: r.createdAt,
       lastUsedAt: r.lastUsedAt,
@@ -100,14 +104,15 @@ export class PtySessionManager {
       name: r.name,
       projectId: r.projectId,
       projectName: r.projectName,
+      sessionType: (r.sessionType || 'claude') as SessionType,
       state: this.live.has(r.id) ? 'running' as const : 'suspended' as const,
       createdAt: r.createdAt,
       lastUsedAt: r.lastUsedAt,
     };
   };
 
-  /** Create a new session — persists to DB and spawns claude with --session-id. */
-  createSession = async (projectId: string, projectName: string, cols: number, rows: number): Promise<SessionInfo> => {
+  /** Create a new session — persists to DB and spawns the appropriate process. */
+  createSession = async (projectId: string, projectName: string, cols: number, rows: number, sessionType: SessionType = 'claude'): Promise<SessionInfo> => {
     const id = this.generateId();
     const claudeSessionId = randomUUID();
     const createdAt = new Date();
@@ -122,14 +127,18 @@ export class PtySessionManager {
       projectId,
       projectName,
       name,
+      sessionType,
       createdAt: now,
       lastUsedAt: now,
     });
 
-    this.log('PTY', `Created session "${name}" (${id}) for project ${projectId}, claude session ${claudeSessionId}`);
+    this.log('PTY', `Created ${sessionType} session "${name}" (${id}) for project ${projectId}`);
 
-    // Spawn claude with --session-id
-    this.spawnClaude(id, claudeSessionId, projectId, cols, rows, false);
+    if (sessionType === 'claude') {
+      this.spawnClaude(id, claudeSessionId, projectId, cols, rows, false);
+    } else {
+      this.spawnShell(id, cols, rows);
+    }
 
     return {
       id,
@@ -137,6 +146,7 @@ export class PtySessionManager {
       name,
       projectId,
       projectName,
+      sessionType,
       state: 'running',
       createdAt: now,
       lastUsedAt: now,
@@ -159,8 +169,12 @@ export class PtySessionManager {
       .set({ lastUsedAt: new Date().toISOString() })
       .where(eq(terminalSessions.id, sessionId));
 
-    // Resume claude
-    this.spawnClaude(sessionId, session.claudeSessionId, session.projectId, cols, rows, true);
+    // Resume based on session type
+    if (session.sessionType === 'terminal') {
+      this.spawnShell(sessionId, cols, rows);
+    } else {
+      this.spawnClaude(sessionId, session.claudeSessionId, session.projectId, cols, rows, true);
+    }
     return true;
   };
 
@@ -319,6 +333,47 @@ export class PtySessionManager {
     });
   };
 
+  private spawnShell = (
+    sessionId: string,
+    cols: number,
+    rows: number,
+  ): void => {
+    this.log('PTY', `Launching plain shell for session ${sessionId}`);
+
+    let spawnedPty: IPty;
+    try {
+      spawnedPty = this.spawn('/bin/bash', [], {
+        name: 'xterm-256color',
+        cols,
+        rows,
+        cwd: this.projectRoot,
+        env: this.buildEnv(),
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      this.log('PTY', `Failed to spawn shell for session ${sessionId}: ${msg}`);
+      return;
+    }
+
+    const entry: LivePty = {
+      pty: spawnedPty,
+      outputBuffer: '',
+      listeners: new Set(),
+      cols,
+      rows,
+    };
+    this.live.set(sessionId, entry);
+
+    spawnedPty.onData((data: string) => {
+      this.emitOutput(entry, data);
+    });
+
+    spawnedPty.onExit(({ exitCode }) => {
+      this.log('PTY', `Shell exited with code ${exitCode} for session ${sessionId}`);
+      this.live.delete(sessionId);
+    });
+  };
+
   private buildEnv = (): Record<string, string> => {
     const env = { ...process.env } as Record<string, string>;
     const home = env.HOME || '/root';